11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * JFFS2 -- Journalling Flash File System, Version 2. 31da177e4SLinus Torvalds * 41da177e4SLinus Torvalds * Copyright (C) 2001-2003 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 * 1031fbdf7aSArtem B. Bityuckiy * $Id: nodemgmt.c,v 1.119 2005/02/28 08:21:05 dedekind Exp $ 111da177e4SLinus Torvalds * 121da177e4SLinus Torvalds */ 131da177e4SLinus Torvalds 141da177e4SLinus Torvalds #include <linux/kernel.h> 151da177e4SLinus Torvalds #include <linux/slab.h> 161da177e4SLinus Torvalds #include <linux/mtd/mtd.h> 171da177e4SLinus Torvalds #include <linux/compiler.h> 181da177e4SLinus Torvalds #include <linux/sched.h> /* For cond_resched() */ 191da177e4SLinus Torvalds #include "nodelist.h" 201da177e4SLinus Torvalds 211da177e4SLinus Torvalds /** 221da177e4SLinus Torvalds * jffs2_reserve_space - request physical space to write nodes to flash 231da177e4SLinus Torvalds * @c: superblock info 241da177e4SLinus Torvalds * @minsize: Minimum acceptable size of allocation 251da177e4SLinus Torvalds * @ofs: Returned value of node offset 261da177e4SLinus Torvalds * @len: Returned value of allocation length 271da177e4SLinus Torvalds * @prio: Allocation type - ALLOC_{NORMAL,DELETION} 281da177e4SLinus Torvalds * 291da177e4SLinus Torvalds * Requests a block of physical space on the flash. Returns zero for success 301da177e4SLinus Torvalds * and puts 'ofs' and 'len' into the appriopriate place, or returns -ENOSPC 311da177e4SLinus Torvalds * or other error if appropriate. 321da177e4SLinus Torvalds * 331da177e4SLinus Torvalds * If it returns zero, jffs2_reserve_space() also downs the per-filesystem 341da177e4SLinus Torvalds * allocation semaphore, to prevent more than one allocation from being 351da177e4SLinus Torvalds * active at any time. The semaphore is later released by jffs2_commit_allocation() 361da177e4SLinus Torvalds * 371da177e4SLinus Torvalds * jffs2_reserve_space() may trigger garbage collection in order to make room 381da177e4SLinus Torvalds * for the requested allocation. 391da177e4SLinus Torvalds */ 401da177e4SLinus Torvalds 411da177e4SLinus Torvalds static int jffs2_do_reserve_space(struct jffs2_sb_info *c, uint32_t minsize, uint32_t *ofs, uint32_t *len); 421da177e4SLinus Torvalds 431da177e4SLinus Torvalds int jffs2_reserve_space(struct jffs2_sb_info *c, uint32_t minsize, uint32_t *ofs, uint32_t *len, int prio) 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)); 511da177e4SLinus Torvalds down(&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 int ret; 611da177e4SLinus Torvalds uint32_t dirty, avail; 621da177e4SLinus Torvalds 631da177e4SLinus Torvalds /* calculate real dirty size 641da177e4SLinus Torvalds * dirty_size contains blocks on erase_pending_list 651da177e4SLinus Torvalds * those blocks are counted in c->nr_erasing_blocks. 661da177e4SLinus Torvalds * If one block is actually erased, it is not longer counted as dirty_space 671da177e4SLinus Torvalds * but it is counted in c->nr_erasing_blocks, so we add it and subtract it 681da177e4SLinus Torvalds * with c->nr_erasing_blocks * c->sector_size again. 691da177e4SLinus Torvalds * Blocks on erasable_list are counted as dirty_size, but not in c->nr_erasing_blocks 701da177e4SLinus Torvalds * This helps us to force gc and pick eventually a clean block to spread the load. 711da177e4SLinus Torvalds * We add unchecked_size here, as we hopefully will find some space to use. 721da177e4SLinus Torvalds * This will affect the sum only once, as gc first finishes checking 731da177e4SLinus Torvalds * of nodes. 741da177e4SLinus Torvalds */ 751da177e4SLinus Torvalds dirty = c->dirty_size + c->erasing_size - c->nr_erasing_blocks * c->sector_size + c->unchecked_size; 761da177e4SLinus Torvalds if (dirty < c->nospc_dirty_size) { 771da177e4SLinus Torvalds if (prio == ALLOC_DELETION && c->nr_free_blocks + c->nr_erasing_blocks >= c->resv_blocks_deletion) { 781da177e4SLinus Torvalds printk(KERN_NOTICE "jffs2_reserve_space(): Low on dirty space to GC, but it's a deletion. Allowing...\n"); 791da177e4SLinus Torvalds break; 801da177e4SLinus Torvalds } 811da177e4SLinus Torvalds D1(printk(KERN_DEBUG "dirty size 0x%08x + unchecked_size 0x%08x < nospc_dirty_size 0x%08x, returning -ENOSPC\n", 821da177e4SLinus Torvalds dirty, c->unchecked_size, c->sector_size)); 831da177e4SLinus Torvalds 841da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 851da177e4SLinus Torvalds up(&c->alloc_sem); 861da177e4SLinus Torvalds return -ENOSPC; 871da177e4SLinus Torvalds } 881da177e4SLinus Torvalds 891da177e4SLinus Torvalds /* Calc possibly available space. Possibly available means that we 901da177e4SLinus Torvalds * don't know, if unchecked size contains obsoleted nodes, which could give us some 911da177e4SLinus Torvalds * more usable space. This will affect the sum only once, as gc first finishes checking 921da177e4SLinus Torvalds * of nodes. 931da177e4SLinus Torvalds + Return -ENOSPC, if the maximum possibly available space is less or equal than 941da177e4SLinus Torvalds * blocksneeded * sector_size. 951da177e4SLinus Torvalds * This blocks endless gc looping on a filesystem, which is nearly full, even if 961da177e4SLinus Torvalds * the check above passes. 971da177e4SLinus Torvalds */ 981da177e4SLinus Torvalds avail = c->free_size + c->dirty_size + c->erasing_size + c->unchecked_size; 991da177e4SLinus Torvalds if ( (avail / c->sector_size) <= blocksneeded) { 1001da177e4SLinus Torvalds if (prio == ALLOC_DELETION && c->nr_free_blocks + c->nr_erasing_blocks >= c->resv_blocks_deletion) { 1011da177e4SLinus Torvalds printk(KERN_NOTICE "jffs2_reserve_space(): Low on possibly available space, but it's a deletion. Allowing...\n"); 1021da177e4SLinus Torvalds break; 1031da177e4SLinus Torvalds } 1041da177e4SLinus Torvalds 1051da177e4SLinus Torvalds D1(printk(KERN_DEBUG "max. available size 0x%08x < blocksneeded * sector_size 0x%08x, returning -ENOSPC\n", 1061da177e4SLinus Torvalds avail, blocksneeded * c->sector_size)); 1071da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 1081da177e4SLinus Torvalds up(&c->alloc_sem); 1091da177e4SLinus Torvalds return -ENOSPC; 1101da177e4SLinus Torvalds } 1111da177e4SLinus Torvalds 1121da177e4SLinus Torvalds up(&c->alloc_sem); 1131da177e4SLinus Torvalds 1141da177e4SLinus 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", 1151da177e4SLinus 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, 1161da177e4SLinus Torvalds c->free_size + c->dirty_size + c->wasted_size + c->used_size + c->erasing_size + c->bad_size, c->flash_size)); 1171da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 1181da177e4SLinus Torvalds 1191da177e4SLinus Torvalds ret = jffs2_garbage_collect_pass(c); 1201da177e4SLinus Torvalds if (ret) 1211da177e4SLinus Torvalds return ret; 1221da177e4SLinus Torvalds 1231da177e4SLinus Torvalds cond_resched(); 1241da177e4SLinus Torvalds 1251da177e4SLinus Torvalds if (signal_pending(current)) 1261da177e4SLinus Torvalds return -EINTR; 1271da177e4SLinus Torvalds 1281da177e4SLinus Torvalds down(&c->alloc_sem); 1291da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 1301da177e4SLinus Torvalds } 1311da177e4SLinus Torvalds 1321da177e4SLinus Torvalds ret = jffs2_do_reserve_space(c, minsize, ofs, len); 1331da177e4SLinus Torvalds if (ret) { 1341da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_reserve_space: ret is %d\n", ret)); 1351da177e4SLinus Torvalds } 1361da177e4SLinus Torvalds } 1371da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 1381da177e4SLinus Torvalds if (ret) 1391da177e4SLinus Torvalds up(&c->alloc_sem); 1401da177e4SLinus Torvalds return ret; 1411da177e4SLinus Torvalds } 1421da177e4SLinus Torvalds 1431da177e4SLinus Torvalds int jffs2_reserve_space_gc(struct jffs2_sb_info *c, uint32_t minsize, uint32_t *ofs, uint32_t *len) 1441da177e4SLinus Torvalds { 1451da177e4SLinus Torvalds int ret = -EAGAIN; 1461da177e4SLinus Torvalds minsize = PAD(minsize); 1471da177e4SLinus Torvalds 1481da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_reserve_space_gc(): Requested 0x%x bytes\n", minsize)); 1491da177e4SLinus Torvalds 1501da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 1511da177e4SLinus Torvalds while(ret == -EAGAIN) { 1521da177e4SLinus Torvalds ret = jffs2_do_reserve_space(c, minsize, ofs, len); 1531da177e4SLinus Torvalds if (ret) { 1541da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_reserve_space_gc: looping, ret is %d\n", ret)); 1551da177e4SLinus Torvalds } 1561da177e4SLinus Torvalds } 1571da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 1581da177e4SLinus Torvalds return ret; 1591da177e4SLinus Torvalds } 1601da177e4SLinus Torvalds 1611da177e4SLinus Torvalds /* Called with alloc sem _and_ erase_completion_lock */ 1621da177e4SLinus Torvalds static int jffs2_do_reserve_space(struct jffs2_sb_info *c, uint32_t minsize, uint32_t *ofs, uint32_t *len) 1631da177e4SLinus Torvalds { 1641da177e4SLinus Torvalds struct jffs2_eraseblock *jeb = c->nextblock; 1651da177e4SLinus Torvalds 1661da177e4SLinus Torvalds restart: 1671da177e4SLinus Torvalds if (jeb && minsize > jeb->free_size) { 1681da177e4SLinus Torvalds /* Skip the end of this block and file it as having some dirty space */ 1691da177e4SLinus Torvalds /* If there's a pending write to it, flush now */ 1701da177e4SLinus Torvalds if (jffs2_wbuf_dirty(c)) { 1711da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 1721da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_do_reserve_space: Flushing write buffer\n")); 1731da177e4SLinus Torvalds jffs2_flush_wbuf_pad(c); 1741da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 1751da177e4SLinus Torvalds jeb = c->nextblock; 1761da177e4SLinus Torvalds goto restart; 1771da177e4SLinus Torvalds } 1781da177e4SLinus Torvalds c->wasted_size += jeb->free_size; 1791da177e4SLinus Torvalds c->free_size -= jeb->free_size; 1801da177e4SLinus Torvalds jeb->wasted_size += jeb->free_size; 1811da177e4SLinus Torvalds jeb->free_size = 0; 1821da177e4SLinus Torvalds 1831da177e4SLinus Torvalds /* Check, if we have a dirty block now, or if it was dirty already */ 1841da177e4SLinus Torvalds if (ISDIRTY (jeb->wasted_size + jeb->dirty_size)) { 1851da177e4SLinus Torvalds c->dirty_size += jeb->wasted_size; 1861da177e4SLinus Torvalds c->wasted_size -= jeb->wasted_size; 1871da177e4SLinus Torvalds jeb->dirty_size += jeb->wasted_size; 1881da177e4SLinus Torvalds jeb->wasted_size = 0; 1891da177e4SLinus Torvalds if (VERYDIRTY(c, jeb->dirty_size)) { 1901da177e4SLinus 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", 1911da177e4SLinus Torvalds jeb->offset, jeb->free_size, jeb->dirty_size, jeb->used_size)); 1921da177e4SLinus Torvalds list_add_tail(&jeb->list, &c->very_dirty_list); 1931da177e4SLinus Torvalds } else { 1941da177e4SLinus 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", 1951da177e4SLinus Torvalds jeb->offset, jeb->free_size, jeb->dirty_size, jeb->used_size)); 1961da177e4SLinus Torvalds list_add_tail(&jeb->list, &c->dirty_list); 1971da177e4SLinus Torvalds } 1981da177e4SLinus Torvalds } else { 1991da177e4SLinus 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", 2001da177e4SLinus Torvalds jeb->offset, jeb->free_size, jeb->dirty_size, jeb->used_size)); 2011da177e4SLinus Torvalds list_add_tail(&jeb->list, &c->clean_list); 2021da177e4SLinus Torvalds } 2031da177e4SLinus Torvalds c->nextblock = jeb = NULL; 2041da177e4SLinus Torvalds } 2051da177e4SLinus Torvalds 2061da177e4SLinus Torvalds if (!jeb) { 2071da177e4SLinus Torvalds struct list_head *next; 2081da177e4SLinus Torvalds /* Take the next block off the 'free' list */ 2091da177e4SLinus Torvalds 2101da177e4SLinus Torvalds if (list_empty(&c->free_list)) { 2111da177e4SLinus Torvalds 2121da177e4SLinus Torvalds if (!c->nr_erasing_blocks && 2131da177e4SLinus Torvalds !list_empty(&c->erasable_list)) { 2141da177e4SLinus Torvalds struct jffs2_eraseblock *ejeb; 2151da177e4SLinus Torvalds 2161da177e4SLinus Torvalds ejeb = list_entry(c->erasable_list.next, struct jffs2_eraseblock, list); 2171da177e4SLinus Torvalds list_del(&ejeb->list); 2181da177e4SLinus Torvalds list_add_tail(&ejeb->list, &c->erase_pending_list); 2191da177e4SLinus Torvalds c->nr_erasing_blocks++; 2201da177e4SLinus Torvalds jffs2_erase_pending_trigger(c); 2211da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_do_reserve_space: Triggering erase of erasable block at 0x%08x\n", 2221da177e4SLinus Torvalds ejeb->offset)); 2231da177e4SLinus Torvalds } 2241da177e4SLinus Torvalds 2251da177e4SLinus Torvalds if (!c->nr_erasing_blocks && 2261da177e4SLinus Torvalds !list_empty(&c->erasable_pending_wbuf_list)) { 2271da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_do_reserve_space: Flushing write buffer\n")); 2281da177e4SLinus Torvalds /* c->nextblock is NULL, no update to c->nextblock allowed */ 2291da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 2301da177e4SLinus Torvalds jffs2_flush_wbuf_pad(c); 2311da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 2321da177e4SLinus Torvalds /* Have another go. It'll be on the erasable_list now */ 2331da177e4SLinus Torvalds return -EAGAIN; 2341da177e4SLinus Torvalds } 2351da177e4SLinus Torvalds 2361da177e4SLinus Torvalds if (!c->nr_erasing_blocks) { 2371da177e4SLinus Torvalds /* Ouch. We're in GC, or we wouldn't have got here. 2381da177e4SLinus Torvalds And there's no space left. At all. */ 2391da177e4SLinus 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", 2401da177e4SLinus Torvalds c->nr_erasing_blocks, c->nr_free_blocks, list_empty(&c->erasable_list)?"yes":"no", 2411da177e4SLinus Torvalds list_empty(&c->erasing_list)?"yes":"no", list_empty(&c->erase_pending_list)?"yes":"no"); 2421da177e4SLinus Torvalds return -ENOSPC; 2431da177e4SLinus Torvalds } 2441da177e4SLinus Torvalds 2451da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 2461da177e4SLinus Torvalds /* Don't wait for it; just erase one right now */ 2471da177e4SLinus Torvalds jffs2_erase_pending_blocks(c, 1); 2481da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 2491da177e4SLinus Torvalds 2501da177e4SLinus Torvalds /* An erase may have failed, decreasing the 2511da177e4SLinus Torvalds amount of free space available. So we must 2521da177e4SLinus Torvalds restart from the beginning */ 2531da177e4SLinus Torvalds return -EAGAIN; 2541da177e4SLinus Torvalds } 2551da177e4SLinus Torvalds 2561da177e4SLinus Torvalds next = c->free_list.next; 2571da177e4SLinus Torvalds list_del(next); 2581da177e4SLinus Torvalds c->nextblock = jeb = list_entry(next, struct jffs2_eraseblock, list); 2591da177e4SLinus Torvalds c->nr_free_blocks--; 2601da177e4SLinus Torvalds 2611da177e4SLinus Torvalds if (jeb->free_size != c->sector_size - c->cleanmarker_size) { 2621da177e4SLinus Torvalds printk(KERN_WARNING "Eep. Block 0x%08x taken from free_list had free_size of 0x%08x!!\n", jeb->offset, jeb->free_size); 2631da177e4SLinus Torvalds goto restart; 2641da177e4SLinus Torvalds } 2651da177e4SLinus Torvalds } 2661da177e4SLinus Torvalds /* OK, jeb (==c->nextblock) is now pointing at a block which definitely has 2671da177e4SLinus Torvalds enough space */ 2681da177e4SLinus Torvalds *ofs = jeb->offset + (c->sector_size - jeb->free_size); 2691da177e4SLinus Torvalds *len = jeb->free_size; 2701da177e4SLinus Torvalds 2711da177e4SLinus Torvalds if (c->cleanmarker_size && jeb->used_size == c->cleanmarker_size && 2721da177e4SLinus Torvalds !jeb->first_node->next_in_ino) { 2731da177e4SLinus Torvalds /* Only node in it beforehand was a CLEANMARKER node (we think). 2741da177e4SLinus Torvalds So mark it obsolete now that there's going to be another node 2751da177e4SLinus Torvalds in the block. This will reduce used_size to zero but We've 2761da177e4SLinus Torvalds already set c->nextblock so that jffs2_mark_node_obsolete() 2771da177e4SLinus Torvalds won't try to refile it to the dirty_list. 2781da177e4SLinus Torvalds */ 2791da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 2801da177e4SLinus Torvalds jffs2_mark_node_obsolete(c, jeb->first_node); 2811da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 2821da177e4SLinus Torvalds } 2831da177e4SLinus Torvalds 2841da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_do_reserve_space(): Giving 0x%x bytes at 0x%x\n", *len, *ofs)); 2851da177e4SLinus Torvalds return 0; 2861da177e4SLinus Torvalds } 2871da177e4SLinus Torvalds 2881da177e4SLinus Torvalds /** 2891da177e4SLinus Torvalds * jffs2_add_physical_node_ref - add a physical node reference to the list 2901da177e4SLinus Torvalds * @c: superblock info 2911da177e4SLinus Torvalds * @new: new node reference to add 2921da177e4SLinus Torvalds * @len: length of this physical node 2931da177e4SLinus Torvalds * @dirty: dirty flag for new node 2941da177e4SLinus Torvalds * 2951da177e4SLinus Torvalds * Should only be used to report nodes for which space has been allocated 2961da177e4SLinus Torvalds * by jffs2_reserve_space. 2971da177e4SLinus Torvalds * 2981da177e4SLinus Torvalds * Must be called with the alloc_sem held. 2991da177e4SLinus Torvalds */ 3001da177e4SLinus Torvalds 3011da177e4SLinus Torvalds int jffs2_add_physical_node_ref(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *new) 3021da177e4SLinus Torvalds { 3031da177e4SLinus Torvalds struct jffs2_eraseblock *jeb; 3041da177e4SLinus Torvalds uint32_t len; 3051da177e4SLinus Torvalds 3061da177e4SLinus Torvalds jeb = &c->blocks[new->flash_offset / c->sector_size]; 3071da177e4SLinus Torvalds len = ref_totlen(c, jeb, new); 3081da177e4SLinus Torvalds 3091da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_add_physical_node_ref(): Node at 0x%x(%d), size 0x%x\n", ref_offset(new), ref_flags(new), len)); 3101da177e4SLinus Torvalds #if 1 3113118db3dSEstelle Hammache /* we could get some obsolete nodes after nextblock was refiled 3123118db3dSEstelle Hammache in wbuf.c */ 3133118db3dSEstelle Hammache if ((c->nextblock || !ref_obsolete(new)) 3149b88f473SEstelle Hammache &&(jeb != c->nextblock || ref_offset(new) != jeb->offset + (c->sector_size - jeb->free_size))) { 3151da177e4SLinus Torvalds printk(KERN_WARNING "argh. node added in wrong place\n"); 3161da177e4SLinus Torvalds jffs2_free_raw_node_ref(new); 3171da177e4SLinus Torvalds return -EINVAL; 3181da177e4SLinus Torvalds } 3191da177e4SLinus Torvalds #endif 3201da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 3211da177e4SLinus Torvalds 3221da177e4SLinus Torvalds if (!jeb->first_node) 3231da177e4SLinus Torvalds jeb->first_node = new; 3241da177e4SLinus Torvalds if (jeb->last_node) 3251da177e4SLinus Torvalds jeb->last_node->next_phys = new; 3261da177e4SLinus Torvalds jeb->last_node = new; 3271da177e4SLinus Torvalds 3281da177e4SLinus Torvalds jeb->free_size -= len; 3291da177e4SLinus Torvalds c->free_size -= len; 3301da177e4SLinus Torvalds if (ref_obsolete(new)) { 3311da177e4SLinus Torvalds jeb->dirty_size += len; 3321da177e4SLinus Torvalds c->dirty_size += len; 3331da177e4SLinus Torvalds } else { 3341da177e4SLinus Torvalds jeb->used_size += len; 3351da177e4SLinus Torvalds c->used_size += len; 3361da177e4SLinus Torvalds } 3371da177e4SLinus Torvalds 3389b88f473SEstelle Hammache if (!jeb->free_size && !jeb->dirty_size && !ISDIRTY(jeb->wasted_size)) { 3391da177e4SLinus Torvalds /* If it lives on the dirty_list, jffs2_reserve_space will put it there */ 3401da177e4SLinus 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", 3411da177e4SLinus Torvalds jeb->offset, jeb->free_size, jeb->dirty_size, jeb->used_size)); 3421da177e4SLinus Torvalds if (jffs2_wbuf_dirty(c)) { 3431da177e4SLinus Torvalds /* Flush the last write in the block if it's outstanding */ 3441da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 3451da177e4SLinus Torvalds jffs2_flush_wbuf_pad(c); 3461da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 3471da177e4SLinus Torvalds } 3481da177e4SLinus Torvalds 3491da177e4SLinus Torvalds list_add_tail(&jeb->list, &c->clean_list); 3501da177e4SLinus Torvalds c->nextblock = NULL; 3511da177e4SLinus Torvalds } 3521da177e4SLinus Torvalds ACCT_SANITY_CHECK(c,jeb); 3531da177e4SLinus Torvalds D1(ACCT_PARANOIA_CHECK(jeb)); 3541da177e4SLinus Torvalds 3551da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 3561da177e4SLinus Torvalds 3571da177e4SLinus Torvalds return 0; 3581da177e4SLinus Torvalds } 3591da177e4SLinus Torvalds 3601da177e4SLinus Torvalds 3611da177e4SLinus Torvalds void jffs2_complete_reservation(struct jffs2_sb_info *c) 3621da177e4SLinus Torvalds { 3631da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_complete_reservation()\n")); 3641da177e4SLinus Torvalds jffs2_garbage_collect_trigger(c); 3651da177e4SLinus Torvalds up(&c->alloc_sem); 3661da177e4SLinus Torvalds } 3671da177e4SLinus Torvalds 3681da177e4SLinus Torvalds static inline int on_list(struct list_head *obj, struct list_head *head) 3691da177e4SLinus Torvalds { 3701da177e4SLinus Torvalds struct list_head *this; 3711da177e4SLinus Torvalds 3721da177e4SLinus Torvalds list_for_each(this, head) { 3731da177e4SLinus Torvalds if (this == obj) { 3741da177e4SLinus Torvalds D1(printk("%p is on list at %p\n", obj, head)); 3751da177e4SLinus Torvalds return 1; 3761da177e4SLinus Torvalds 3771da177e4SLinus Torvalds } 3781da177e4SLinus Torvalds } 3791da177e4SLinus Torvalds return 0; 3801da177e4SLinus Torvalds } 3811da177e4SLinus Torvalds 3821da177e4SLinus Torvalds void jffs2_mark_node_obsolete(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *ref) 3831da177e4SLinus Torvalds { 3841da177e4SLinus Torvalds struct jffs2_eraseblock *jeb; 3851da177e4SLinus Torvalds int blocknr; 3861da177e4SLinus Torvalds struct jffs2_unknown_node n; 3871da177e4SLinus Torvalds int ret, addedsize; 3881da177e4SLinus Torvalds size_t retlen; 3891da177e4SLinus Torvalds 3901da177e4SLinus Torvalds if(!ref) { 3911da177e4SLinus Torvalds printk(KERN_NOTICE "EEEEEK. jffs2_mark_node_obsolete called with NULL node\n"); 3921da177e4SLinus Torvalds return; 3931da177e4SLinus Torvalds } 3941da177e4SLinus Torvalds if (ref_obsolete(ref)) { 3951da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_mark_node_obsolete called with already obsolete node at 0x%08x\n", ref_offset(ref))); 3961da177e4SLinus Torvalds return; 3971da177e4SLinus Torvalds } 3981da177e4SLinus Torvalds blocknr = ref->flash_offset / c->sector_size; 3991da177e4SLinus Torvalds if (blocknr >= c->nr_blocks) { 4001da177e4SLinus Torvalds printk(KERN_NOTICE "raw node at 0x%08x is off the end of device!\n", ref->flash_offset); 4011da177e4SLinus Torvalds BUG(); 4021da177e4SLinus Torvalds } 4031da177e4SLinus Torvalds jeb = &c->blocks[blocknr]; 4041da177e4SLinus Torvalds 4051da177e4SLinus Torvalds if (jffs2_can_mark_obsolete(c) && !jffs2_is_readonly(c) && 40631fbdf7aSArtem B. Bityuckiy !(c->flags & (JFFS2_SB_FLAG_SCANNING | JFFS2_SB_FLAG_BUILDING))) { 4071da177e4SLinus Torvalds /* Hm. This may confuse static lock analysis. If any of the above 4081da177e4SLinus Torvalds three conditions is false, we're going to return from this 4091da177e4SLinus Torvalds function without actually obliterating any nodes or freeing 4101da177e4SLinus Torvalds any jffs2_raw_node_refs. So we don't need to stop erases from 4111da177e4SLinus Torvalds happening, or protect against people holding an obsolete 4121da177e4SLinus Torvalds jffs2_raw_node_ref without the erase_completion_lock. */ 4131da177e4SLinus Torvalds down(&c->erase_free_sem); 4141da177e4SLinus Torvalds } 4151da177e4SLinus Torvalds 4161da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 4171da177e4SLinus Torvalds 4181da177e4SLinus Torvalds if (ref_flags(ref) == REF_UNCHECKED) { 4191da177e4SLinus Torvalds D1(if (unlikely(jeb->unchecked_size < ref_totlen(c, jeb, ref))) { 4201da177e4SLinus 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", 4211da177e4SLinus Torvalds ref_totlen(c, jeb, ref), blocknr, ref->flash_offset, jeb->used_size); 4221da177e4SLinus Torvalds BUG(); 4231da177e4SLinus Torvalds }) 4241da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Obsoleting previously unchecked node at 0x%08x of len %x: ", ref_offset(ref), ref_totlen(c, jeb, ref))); 4251da177e4SLinus Torvalds jeb->unchecked_size -= ref_totlen(c, jeb, ref); 4261da177e4SLinus Torvalds c->unchecked_size -= ref_totlen(c, jeb, ref); 4271da177e4SLinus Torvalds } else { 4281da177e4SLinus Torvalds D1(if (unlikely(jeb->used_size < ref_totlen(c, jeb, ref))) { 4291da177e4SLinus 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", 4301da177e4SLinus Torvalds ref_totlen(c, jeb, ref), blocknr, ref->flash_offset, jeb->used_size); 4311da177e4SLinus Torvalds BUG(); 4321da177e4SLinus Torvalds }) 4331da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Obsoleting node at 0x%08x of len %x: ", ref_offset(ref), ref_totlen(c, jeb, ref))); 4341da177e4SLinus Torvalds jeb->used_size -= ref_totlen(c, jeb, ref); 4351da177e4SLinus Torvalds c->used_size -= ref_totlen(c, jeb, ref); 4361da177e4SLinus Torvalds } 4371da177e4SLinus Torvalds 4381da177e4SLinus Torvalds // Take care, that wasted size is taken into concern 4391da177e4SLinus Torvalds if ((jeb->dirty_size || ISDIRTY(jeb->wasted_size + ref_totlen(c, jeb, ref))) && jeb != c->nextblock) { 4401da177e4SLinus Torvalds D1(printk("Dirtying\n")); 4411da177e4SLinus Torvalds addedsize = ref_totlen(c, jeb, ref); 4421da177e4SLinus Torvalds jeb->dirty_size += ref_totlen(c, jeb, ref); 4431da177e4SLinus Torvalds c->dirty_size += ref_totlen(c, jeb, ref); 4441da177e4SLinus Torvalds 4451da177e4SLinus Torvalds /* Convert wasted space to dirty, if not a bad block */ 4461da177e4SLinus Torvalds if (jeb->wasted_size) { 4471da177e4SLinus Torvalds if (on_list(&jeb->list, &c->bad_used_list)) { 4481da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Leaving block at %08x on the bad_used_list\n", 4491da177e4SLinus Torvalds jeb->offset)); 4501da177e4SLinus Torvalds addedsize = 0; /* To fool the refiling code later */ 4511da177e4SLinus Torvalds } else { 4521da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Converting %d bytes of wasted space to dirty in block at %08x\n", 4531da177e4SLinus Torvalds jeb->wasted_size, jeb->offset)); 4541da177e4SLinus Torvalds addedsize += jeb->wasted_size; 4551da177e4SLinus Torvalds jeb->dirty_size += jeb->wasted_size; 4561da177e4SLinus Torvalds c->dirty_size += jeb->wasted_size; 4571da177e4SLinus Torvalds c->wasted_size -= jeb->wasted_size; 4581da177e4SLinus Torvalds jeb->wasted_size = 0; 4591da177e4SLinus Torvalds } 4601da177e4SLinus Torvalds } 4611da177e4SLinus Torvalds } else { 4621da177e4SLinus Torvalds D1(printk("Wasting\n")); 4631da177e4SLinus Torvalds addedsize = 0; 4641da177e4SLinus Torvalds jeb->wasted_size += ref_totlen(c, jeb, ref); 4651da177e4SLinus Torvalds c->wasted_size += ref_totlen(c, jeb, ref); 4661da177e4SLinus Torvalds } 4671da177e4SLinus Torvalds ref->flash_offset = ref_offset(ref) | REF_OBSOLETE; 4681da177e4SLinus Torvalds 4691da177e4SLinus Torvalds ACCT_SANITY_CHECK(c, jeb); 4701da177e4SLinus Torvalds 4711da177e4SLinus Torvalds D1(ACCT_PARANOIA_CHECK(jeb)); 4721da177e4SLinus Torvalds 47331fbdf7aSArtem B. Bityuckiy if (c->flags & JFFS2_SB_FLAG_SCANNING) { 47431fbdf7aSArtem B. Bityuckiy /* Flash scanning is in progress. Don't muck about with the block 4751da177e4SLinus Torvalds lists because they're not ready yet, and don't actually 4761da177e4SLinus Torvalds obliterate nodes that look obsolete. If they weren't 4771da177e4SLinus Torvalds marked obsolete on the flash at the time they _became_ 4781da177e4SLinus Torvalds obsolete, there was probably a reason for that. */ 4791da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 4801da177e4SLinus Torvalds /* We didn't lock the erase_free_sem */ 4811da177e4SLinus Torvalds return; 4821da177e4SLinus Torvalds } 4831da177e4SLinus Torvalds 4841da177e4SLinus Torvalds if (jeb == c->nextblock) { 4851da177e4SLinus Torvalds D2(printk(KERN_DEBUG "Not moving nextblock 0x%08x to dirty/erase_pending list\n", jeb->offset)); 4861da177e4SLinus Torvalds } else if (!jeb->used_size && !jeb->unchecked_size) { 4871da177e4SLinus Torvalds if (jeb == c->gcblock) { 4881da177e4SLinus Torvalds D1(printk(KERN_DEBUG "gcblock at 0x%08x completely dirtied. Clearing gcblock...\n", jeb->offset)); 4891da177e4SLinus Torvalds c->gcblock = NULL; 4901da177e4SLinus Torvalds } else { 4911da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Eraseblock at 0x%08x completely dirtied. Removing from (dirty?) list...\n", jeb->offset)); 4921da177e4SLinus Torvalds list_del(&jeb->list); 4931da177e4SLinus Torvalds } 4941da177e4SLinus Torvalds if (jffs2_wbuf_dirty(c)) { 4951da177e4SLinus Torvalds D1(printk(KERN_DEBUG "...and adding to erasable_pending_wbuf_list\n")); 4961da177e4SLinus Torvalds list_add_tail(&jeb->list, &c->erasable_pending_wbuf_list); 4971da177e4SLinus Torvalds } else { 4981da177e4SLinus Torvalds if (jiffies & 127) { 4991da177e4SLinus Torvalds /* Most of the time, we just erase it immediately. Otherwise we 5001da177e4SLinus Torvalds spend ages scanning it on mount, etc. */ 5011da177e4SLinus Torvalds D1(printk(KERN_DEBUG "...and adding to erase_pending_list\n")); 5021da177e4SLinus Torvalds list_add_tail(&jeb->list, &c->erase_pending_list); 5031da177e4SLinus Torvalds c->nr_erasing_blocks++; 5041da177e4SLinus Torvalds jffs2_erase_pending_trigger(c); 5051da177e4SLinus Torvalds } else { 5061da177e4SLinus Torvalds /* Sometimes, however, we leave it elsewhere so it doesn't get 5071da177e4SLinus Torvalds immediately reused, and we spread the load a bit. */ 5081da177e4SLinus Torvalds D1(printk(KERN_DEBUG "...and adding to erasable_list\n")); 5091da177e4SLinus Torvalds list_add_tail(&jeb->list, &c->erasable_list); 5101da177e4SLinus Torvalds } 5111da177e4SLinus Torvalds } 5121da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Done OK\n")); 5131da177e4SLinus Torvalds } else if (jeb == c->gcblock) { 5141da177e4SLinus Torvalds D2(printk(KERN_DEBUG "Not moving gcblock 0x%08x to dirty_list\n", jeb->offset)); 5151da177e4SLinus Torvalds } else if (ISDIRTY(jeb->dirty_size) && !ISDIRTY(jeb->dirty_size - addedsize)) { 5161da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Eraseblock at 0x%08x is freshly dirtied. Removing from clean list...\n", jeb->offset)); 5171da177e4SLinus Torvalds list_del(&jeb->list); 5181da177e4SLinus Torvalds D1(printk(KERN_DEBUG "...and adding to dirty_list\n")); 5191da177e4SLinus Torvalds list_add_tail(&jeb->list, &c->dirty_list); 5201da177e4SLinus Torvalds } else if (VERYDIRTY(c, jeb->dirty_size) && 5211da177e4SLinus Torvalds !VERYDIRTY(c, jeb->dirty_size - addedsize)) { 5221da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Eraseblock at 0x%08x is now very dirty. Removing from dirty list...\n", jeb->offset)); 5231da177e4SLinus Torvalds list_del(&jeb->list); 5241da177e4SLinus Torvalds D1(printk(KERN_DEBUG "...and adding to very_dirty_list\n")); 5251da177e4SLinus Torvalds list_add_tail(&jeb->list, &c->very_dirty_list); 5261da177e4SLinus Torvalds } else { 5271da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Eraseblock at 0x%08x not moved anywhere. (free 0x%08x, dirty 0x%08x, used 0x%08x)\n", 5281da177e4SLinus Torvalds jeb->offset, jeb->free_size, jeb->dirty_size, jeb->used_size)); 5291da177e4SLinus Torvalds } 5301da177e4SLinus Torvalds 5311da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 5321da177e4SLinus Torvalds 53331fbdf7aSArtem B. Bityuckiy if (!jffs2_can_mark_obsolete(c) || jffs2_is_readonly(c) || 53431fbdf7aSArtem B. Bityuckiy (c->flags & JFFS2_SB_FLAG_BUILDING)) { 5351da177e4SLinus Torvalds /* We didn't lock the erase_free_sem */ 5361da177e4SLinus Torvalds return; 5371da177e4SLinus Torvalds } 5381da177e4SLinus Torvalds 5391da177e4SLinus Torvalds /* The erase_free_sem is locked, and has been since before we marked the node obsolete 5401da177e4SLinus Torvalds and potentially put its eraseblock onto the erase_pending_list. Thus, we know that 5411da177e4SLinus Torvalds the block hasn't _already_ been erased, and that 'ref' itself hasn't been freed yet 5421da177e4SLinus Torvalds by jffs2_free_all_node_refs() in erase.c. Which is nice. */ 5431da177e4SLinus Torvalds 5441da177e4SLinus Torvalds D1(printk(KERN_DEBUG "obliterating obsoleted node at 0x%08x\n", ref_offset(ref))); 5451da177e4SLinus Torvalds ret = jffs2_flash_read(c, ref_offset(ref), sizeof(n), &retlen, (char *)&n); 5461da177e4SLinus Torvalds if (ret) { 5471da177e4SLinus Torvalds printk(KERN_WARNING "Read error reading from obsoleted node at 0x%08x: %d\n", ref_offset(ref), ret); 5481da177e4SLinus Torvalds goto out_erase_sem; 5491da177e4SLinus Torvalds } 5501da177e4SLinus Torvalds if (retlen != sizeof(n)) { 5511da177e4SLinus Torvalds printk(KERN_WARNING "Short read from obsoleted node at 0x%08x: %zd\n", ref_offset(ref), retlen); 5521da177e4SLinus Torvalds goto out_erase_sem; 5531da177e4SLinus Torvalds } 5541da177e4SLinus Torvalds if (PAD(je32_to_cpu(n.totlen)) != PAD(ref_totlen(c, jeb, ref))) { 5551da177e4SLinus Torvalds printk(KERN_WARNING "Node totlen on flash (0x%08x) != totlen from node ref (0x%08x)\n", je32_to_cpu(n.totlen), ref_totlen(c, jeb, ref)); 5561da177e4SLinus Torvalds goto out_erase_sem; 5571da177e4SLinus Torvalds } 5581da177e4SLinus Torvalds if (!(je16_to_cpu(n.nodetype) & JFFS2_NODE_ACCURATE)) { 5591da177e4SLinus 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))); 5601da177e4SLinus Torvalds goto out_erase_sem; 5611da177e4SLinus Torvalds } 5621da177e4SLinus Torvalds /* XXX FIXME: This is ugly now */ 5631da177e4SLinus Torvalds n.nodetype = cpu_to_je16(je16_to_cpu(n.nodetype) & ~JFFS2_NODE_ACCURATE); 5641da177e4SLinus Torvalds ret = jffs2_flash_write(c, ref_offset(ref), sizeof(n), &retlen, (char *)&n); 5651da177e4SLinus Torvalds if (ret) { 5661da177e4SLinus Torvalds printk(KERN_WARNING "Write error in obliterating obsoleted node at 0x%08x: %d\n", ref_offset(ref), ret); 5671da177e4SLinus Torvalds goto out_erase_sem; 5681da177e4SLinus Torvalds } 5691da177e4SLinus Torvalds if (retlen != sizeof(n)) { 5701da177e4SLinus Torvalds printk(KERN_WARNING "Short write in obliterating obsoleted node at 0x%08x: %zd\n", ref_offset(ref), retlen); 5711da177e4SLinus Torvalds goto out_erase_sem; 5721da177e4SLinus Torvalds } 5731da177e4SLinus Torvalds 5741da177e4SLinus Torvalds /* Nodes which have been marked obsolete no longer need to be 5751da177e4SLinus Torvalds associated with any inode. Remove them from the per-inode list. 5761da177e4SLinus Torvalds 5771da177e4SLinus Torvalds Note we can't do this for NAND at the moment because we need 5781da177e4SLinus Torvalds obsolete dirent nodes to stay on the lists, because of the 5791da177e4SLinus Torvalds horridness in jffs2_garbage_collect_deletion_dirent(). Also 5801da177e4SLinus Torvalds because we delete the inocache, and on NAND we need that to 5811da177e4SLinus Torvalds stay around until all the nodes are actually erased, in order 5821da177e4SLinus Torvalds to stop us from giving the same inode number to another newly 5831da177e4SLinus Torvalds created inode. */ 5841da177e4SLinus Torvalds if (ref->next_in_ino) { 5851da177e4SLinus Torvalds struct jffs2_inode_cache *ic; 5861da177e4SLinus Torvalds struct jffs2_raw_node_ref **p; 5871da177e4SLinus Torvalds 5881da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 5891da177e4SLinus Torvalds 5901da177e4SLinus Torvalds ic = jffs2_raw_ref_to_ic(ref); 5911da177e4SLinus Torvalds for (p = &ic->nodes; (*p) != ref; p = &((*p)->next_in_ino)) 5921da177e4SLinus Torvalds ; 5931da177e4SLinus Torvalds 5941da177e4SLinus Torvalds *p = ref->next_in_ino; 5951da177e4SLinus Torvalds ref->next_in_ino = NULL; 5961da177e4SLinus Torvalds 59767e345d1SDavid Woodhouse if (ic->nodes == (void *)ic) 5981da177e4SLinus Torvalds jffs2_del_ino_cache(c, ic); 5991da177e4SLinus Torvalds 6001da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 6011da177e4SLinus Torvalds } 6021da177e4SLinus Torvalds 6031da177e4SLinus Torvalds 6041da177e4SLinus Torvalds /* Merge with the next node in the physical list, if there is one 6051da177e4SLinus Torvalds and if it's also obsolete and if it doesn't belong to any inode */ 6061da177e4SLinus Torvalds if (ref->next_phys && ref_obsolete(ref->next_phys) && 6071da177e4SLinus Torvalds !ref->next_phys->next_in_ino) { 6081da177e4SLinus Torvalds struct jffs2_raw_node_ref *n = ref->next_phys; 6091da177e4SLinus Torvalds 6101da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 6111da177e4SLinus Torvalds 6121da177e4SLinus Torvalds ref->__totlen += n->__totlen; 6131da177e4SLinus Torvalds ref->next_phys = n->next_phys; 6141da177e4SLinus Torvalds if (jeb->last_node == n) jeb->last_node = ref; 6151da177e4SLinus Torvalds if (jeb->gc_node == n) { 6161da177e4SLinus Torvalds /* gc will be happy continuing gc on this node */ 6171da177e4SLinus Torvalds jeb->gc_node=ref; 6181da177e4SLinus Torvalds } 6191da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 6201da177e4SLinus Torvalds 6211da177e4SLinus Torvalds jffs2_free_raw_node_ref(n); 6221da177e4SLinus Torvalds } 6231da177e4SLinus Torvalds 6241da177e4SLinus Torvalds /* Also merge with the previous node in the list, if there is one 6251da177e4SLinus Torvalds and that one is obsolete */ 6261da177e4SLinus Torvalds if (ref != jeb->first_node ) { 6271da177e4SLinus Torvalds struct jffs2_raw_node_ref *p = jeb->first_node; 6281da177e4SLinus Torvalds 6291da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 6301da177e4SLinus Torvalds 6311da177e4SLinus Torvalds while (p->next_phys != ref) 6321da177e4SLinus Torvalds p = p->next_phys; 6331da177e4SLinus Torvalds 6341da177e4SLinus Torvalds if (ref_obsolete(p) && !ref->next_in_ino) { 6351da177e4SLinus Torvalds p->__totlen += ref->__totlen; 6361da177e4SLinus Torvalds if (jeb->last_node == ref) { 6371da177e4SLinus Torvalds jeb->last_node = p; 6381da177e4SLinus Torvalds } 6391da177e4SLinus Torvalds if (jeb->gc_node == ref) { 6401da177e4SLinus Torvalds /* gc will be happy continuing gc on this node */ 6411da177e4SLinus Torvalds jeb->gc_node=p; 6421da177e4SLinus Torvalds } 6431da177e4SLinus Torvalds p->next_phys = ref->next_phys; 6441da177e4SLinus Torvalds jffs2_free_raw_node_ref(ref); 6451da177e4SLinus Torvalds } 6461da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 6471da177e4SLinus Torvalds } 6481da177e4SLinus Torvalds out_erase_sem: 6491da177e4SLinus Torvalds up(&c->erase_free_sem); 6501da177e4SLinus Torvalds } 6511da177e4SLinus Torvalds 6521da177e4SLinus Torvalds #if CONFIG_JFFS2_FS_DEBUG >= 2 6531da177e4SLinus Torvalds void jffs2_dump_block_lists(struct jffs2_sb_info *c) 6541da177e4SLinus Torvalds { 6551da177e4SLinus Torvalds 6561da177e4SLinus Torvalds 6571da177e4SLinus Torvalds printk(KERN_DEBUG "jffs2_dump_block_lists:\n"); 6581da177e4SLinus Torvalds printk(KERN_DEBUG "flash_size: %08x\n", c->flash_size); 6591da177e4SLinus Torvalds printk(KERN_DEBUG "used_size: %08x\n", c->used_size); 6601da177e4SLinus Torvalds printk(KERN_DEBUG "dirty_size: %08x\n", c->dirty_size); 6611da177e4SLinus Torvalds printk(KERN_DEBUG "wasted_size: %08x\n", c->wasted_size); 6621da177e4SLinus Torvalds printk(KERN_DEBUG "unchecked_size: %08x\n", c->unchecked_size); 6631da177e4SLinus Torvalds printk(KERN_DEBUG "free_size: %08x\n", c->free_size); 6641da177e4SLinus Torvalds printk(KERN_DEBUG "erasing_size: %08x\n", c->erasing_size); 6651da177e4SLinus Torvalds printk(KERN_DEBUG "bad_size: %08x\n", c->bad_size); 6661da177e4SLinus Torvalds printk(KERN_DEBUG "sector_size: %08x\n", c->sector_size); 6671da177e4SLinus Torvalds printk(KERN_DEBUG "jffs2_reserved_blocks size: %08x\n",c->sector_size * c->resv_blocks_write); 6681da177e4SLinus Torvalds 6691da177e4SLinus Torvalds if (c->nextblock) { 6701da177e4SLinus Torvalds printk(KERN_DEBUG "nextblock: %08x (used %08x, dirty %08x, wasted %08x, unchecked %08x, free %08x)\n", 6711da177e4SLinus Torvalds c->nextblock->offset, c->nextblock->used_size, c->nextblock->dirty_size, c->nextblock->wasted_size, c->nextblock->unchecked_size, c->nextblock->free_size); 6721da177e4SLinus Torvalds } else { 6731da177e4SLinus Torvalds printk(KERN_DEBUG "nextblock: NULL\n"); 6741da177e4SLinus Torvalds } 6751da177e4SLinus Torvalds if (c->gcblock) { 6761da177e4SLinus Torvalds printk(KERN_DEBUG "gcblock: %08x (used %08x, dirty %08x, wasted %08x, unchecked %08x, free %08x)\n", 6771da177e4SLinus Torvalds c->gcblock->offset, c->gcblock->used_size, c->gcblock->dirty_size, c->gcblock->wasted_size, c->gcblock->unchecked_size, c->gcblock->free_size); 6781da177e4SLinus Torvalds } else { 6791da177e4SLinus Torvalds printk(KERN_DEBUG "gcblock: NULL\n"); 6801da177e4SLinus Torvalds } 6811da177e4SLinus Torvalds if (list_empty(&c->clean_list)) { 6821da177e4SLinus Torvalds printk(KERN_DEBUG "clean_list: empty\n"); 6831da177e4SLinus Torvalds } else { 6841da177e4SLinus Torvalds struct list_head *this; 6851da177e4SLinus Torvalds int numblocks = 0; 6861da177e4SLinus Torvalds uint32_t dirty = 0; 6871da177e4SLinus Torvalds 6881da177e4SLinus Torvalds list_for_each(this, &c->clean_list) { 6891da177e4SLinus Torvalds struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list); 6901da177e4SLinus Torvalds numblocks ++; 6911da177e4SLinus Torvalds dirty += jeb->wasted_size; 6921da177e4SLinus Torvalds printk(KERN_DEBUG "clean_list: %08x (used %08x, dirty %08x, wasted %08x, unchecked %08x, free %08x)\n", jeb->offset, jeb->used_size, jeb->dirty_size, jeb->wasted_size, jeb->unchecked_size, jeb->free_size); 6931da177e4SLinus Torvalds } 6941da177e4SLinus Torvalds printk (KERN_DEBUG "Contains %d blocks with total wasted size %u, average wasted size: %u\n", numblocks, dirty, dirty / numblocks); 6951da177e4SLinus Torvalds } 6961da177e4SLinus Torvalds if (list_empty(&c->very_dirty_list)) { 6971da177e4SLinus Torvalds printk(KERN_DEBUG "very_dirty_list: empty\n"); 6981da177e4SLinus Torvalds } else { 6991da177e4SLinus Torvalds struct list_head *this; 7001da177e4SLinus Torvalds int numblocks = 0; 7011da177e4SLinus Torvalds uint32_t dirty = 0; 7021da177e4SLinus Torvalds 7031da177e4SLinus Torvalds list_for_each(this, &c->very_dirty_list) { 7041da177e4SLinus Torvalds struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list); 7051da177e4SLinus Torvalds numblocks ++; 7061da177e4SLinus Torvalds dirty += jeb->dirty_size; 7071da177e4SLinus Torvalds printk(KERN_DEBUG "very_dirty_list: %08x (used %08x, dirty %08x, wasted %08x, unchecked %08x, free %08x)\n", 7081da177e4SLinus Torvalds jeb->offset, jeb->used_size, jeb->dirty_size, jeb->wasted_size, jeb->unchecked_size, jeb->free_size); 7091da177e4SLinus Torvalds } 7101da177e4SLinus Torvalds printk (KERN_DEBUG "Contains %d blocks with total dirty size %u, average dirty size: %u\n", 7111da177e4SLinus Torvalds numblocks, dirty, dirty / numblocks); 7121da177e4SLinus Torvalds } 7131da177e4SLinus Torvalds if (list_empty(&c->dirty_list)) { 7141da177e4SLinus Torvalds printk(KERN_DEBUG "dirty_list: empty\n"); 7151da177e4SLinus Torvalds } else { 7161da177e4SLinus Torvalds struct list_head *this; 7171da177e4SLinus Torvalds int numblocks = 0; 7181da177e4SLinus Torvalds uint32_t dirty = 0; 7191da177e4SLinus Torvalds 7201da177e4SLinus Torvalds list_for_each(this, &c->dirty_list) { 7211da177e4SLinus Torvalds struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list); 7221da177e4SLinus Torvalds numblocks ++; 7231da177e4SLinus Torvalds dirty += jeb->dirty_size; 7241da177e4SLinus Torvalds printk(KERN_DEBUG "dirty_list: %08x (used %08x, dirty %08x, wasted %08x, unchecked %08x, free %08x)\n", 7251da177e4SLinus Torvalds jeb->offset, jeb->used_size, jeb->dirty_size, jeb->wasted_size, jeb->unchecked_size, jeb->free_size); 7261da177e4SLinus Torvalds } 7271da177e4SLinus Torvalds printk (KERN_DEBUG "Contains %d blocks with total dirty size %u, average dirty size: %u\n", 7281da177e4SLinus Torvalds numblocks, dirty, dirty / numblocks); 7291da177e4SLinus Torvalds } 7301da177e4SLinus Torvalds if (list_empty(&c->erasable_list)) { 7311da177e4SLinus Torvalds printk(KERN_DEBUG "erasable_list: empty\n"); 7321da177e4SLinus Torvalds } else { 7331da177e4SLinus Torvalds struct list_head *this; 7341da177e4SLinus Torvalds 7351da177e4SLinus Torvalds list_for_each(this, &c->erasable_list) { 7361da177e4SLinus Torvalds struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list); 7371da177e4SLinus Torvalds printk(KERN_DEBUG "erasable_list: %08x (used %08x, dirty %08x, wasted %08x, unchecked %08x, free %08x)\n", 7381da177e4SLinus Torvalds jeb->offset, jeb->used_size, jeb->dirty_size, jeb->wasted_size, jeb->unchecked_size, jeb->free_size); 7391da177e4SLinus Torvalds } 7401da177e4SLinus Torvalds } 7411da177e4SLinus Torvalds if (list_empty(&c->erasing_list)) { 7421da177e4SLinus Torvalds printk(KERN_DEBUG "erasing_list: empty\n"); 7431da177e4SLinus Torvalds } else { 7441da177e4SLinus Torvalds struct list_head *this; 7451da177e4SLinus Torvalds 7461da177e4SLinus Torvalds list_for_each(this, &c->erasing_list) { 7471da177e4SLinus Torvalds struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list); 7481da177e4SLinus Torvalds printk(KERN_DEBUG "erasing_list: %08x (used %08x, dirty %08x, wasted %08x, unchecked %08x, free %08x)\n", 7491da177e4SLinus Torvalds jeb->offset, jeb->used_size, jeb->dirty_size, jeb->wasted_size, jeb->unchecked_size, jeb->free_size); 7501da177e4SLinus Torvalds } 7511da177e4SLinus Torvalds } 7521da177e4SLinus Torvalds if (list_empty(&c->erase_pending_list)) { 7531da177e4SLinus Torvalds printk(KERN_DEBUG "erase_pending_list: empty\n"); 7541da177e4SLinus Torvalds } else { 7551da177e4SLinus Torvalds struct list_head *this; 7561da177e4SLinus Torvalds 7571da177e4SLinus Torvalds list_for_each(this, &c->erase_pending_list) { 7581da177e4SLinus Torvalds struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list); 7591da177e4SLinus Torvalds printk(KERN_DEBUG "erase_pending_list: %08x (used %08x, dirty %08x, wasted %08x, unchecked %08x, free %08x)\n", 7601da177e4SLinus Torvalds jeb->offset, jeb->used_size, jeb->dirty_size, jeb->wasted_size, jeb->unchecked_size, jeb->free_size); 7611da177e4SLinus Torvalds } 7621da177e4SLinus Torvalds } 7631da177e4SLinus Torvalds if (list_empty(&c->erasable_pending_wbuf_list)) { 7641da177e4SLinus Torvalds printk(KERN_DEBUG "erasable_pending_wbuf_list: empty\n"); 7651da177e4SLinus Torvalds } else { 7661da177e4SLinus Torvalds struct list_head *this; 7671da177e4SLinus Torvalds 7681da177e4SLinus Torvalds list_for_each(this, &c->erasable_pending_wbuf_list) { 7691da177e4SLinus Torvalds struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list); 7701da177e4SLinus Torvalds printk(KERN_DEBUG "erasable_pending_wbuf_list: %08x (used %08x, dirty %08x, wasted %08x, unchecked %08x, free %08x)\n", 7711da177e4SLinus Torvalds jeb->offset, jeb->used_size, jeb->dirty_size, jeb->wasted_size, jeb->unchecked_size, jeb->free_size); 7721da177e4SLinus Torvalds } 7731da177e4SLinus Torvalds } 7741da177e4SLinus Torvalds if (list_empty(&c->free_list)) { 7751da177e4SLinus Torvalds printk(KERN_DEBUG "free_list: empty\n"); 7761da177e4SLinus Torvalds } else { 7771da177e4SLinus Torvalds struct list_head *this; 7781da177e4SLinus Torvalds 7791da177e4SLinus Torvalds list_for_each(this, &c->free_list) { 7801da177e4SLinus Torvalds struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list); 7811da177e4SLinus Torvalds printk(KERN_DEBUG "free_list: %08x (used %08x, dirty %08x, wasted %08x, unchecked %08x, free %08x)\n", 7821da177e4SLinus Torvalds jeb->offset, jeb->used_size, jeb->dirty_size, jeb->wasted_size, jeb->unchecked_size, jeb->free_size); 7831da177e4SLinus Torvalds } 7841da177e4SLinus Torvalds } 7851da177e4SLinus Torvalds if (list_empty(&c->bad_list)) { 7861da177e4SLinus Torvalds printk(KERN_DEBUG "bad_list: empty\n"); 7871da177e4SLinus Torvalds } else { 7881da177e4SLinus Torvalds struct list_head *this; 7891da177e4SLinus Torvalds 7901da177e4SLinus Torvalds list_for_each(this, &c->bad_list) { 7911da177e4SLinus Torvalds struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list); 7921da177e4SLinus Torvalds printk(KERN_DEBUG "bad_list: %08x (used %08x, dirty %08x, wasted %08x, unchecked %08x, free %08x)\n", 7931da177e4SLinus Torvalds jeb->offset, jeb->used_size, jeb->dirty_size, jeb->wasted_size, jeb->unchecked_size, jeb->free_size); 7941da177e4SLinus Torvalds } 7951da177e4SLinus Torvalds } 7961da177e4SLinus Torvalds if (list_empty(&c->bad_used_list)) { 7971da177e4SLinus Torvalds printk(KERN_DEBUG "bad_used_list: empty\n"); 7981da177e4SLinus Torvalds } else { 7991da177e4SLinus Torvalds struct list_head *this; 8001da177e4SLinus Torvalds 8011da177e4SLinus Torvalds list_for_each(this, &c->bad_used_list) { 8021da177e4SLinus Torvalds struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list); 8031da177e4SLinus Torvalds printk(KERN_DEBUG "bad_used_list: %08x (used %08x, dirty %08x, wasted %08x, unchecked %08x, free %08x)\n", 8041da177e4SLinus Torvalds jeb->offset, jeb->used_size, jeb->dirty_size, jeb->wasted_size, jeb->unchecked_size, jeb->free_size); 8051da177e4SLinus Torvalds } 8061da177e4SLinus Torvalds } 8071da177e4SLinus Torvalds } 8081da177e4SLinus Torvalds #endif /* CONFIG_JFFS2_FS_DEBUG */ 8091da177e4SLinus Torvalds 8101da177e4SLinus Torvalds int jffs2_thread_should_wake(struct jffs2_sb_info *c) 8111da177e4SLinus Torvalds { 8121da177e4SLinus Torvalds int ret = 0; 8131da177e4SLinus Torvalds uint32_t dirty; 8141da177e4SLinus Torvalds 8151da177e4SLinus Torvalds if (c->unchecked_size) { 8161da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_thread_should_wake(): unchecked_size %d, checked_ino #%d\n", 8171da177e4SLinus Torvalds c->unchecked_size, c->checked_ino)); 8181da177e4SLinus Torvalds return 1; 8191da177e4SLinus Torvalds } 8201da177e4SLinus Torvalds 8211da177e4SLinus Torvalds /* dirty_size contains blocks on erase_pending_list 8221da177e4SLinus Torvalds * those blocks are counted in c->nr_erasing_blocks. 8231da177e4SLinus Torvalds * If one block is actually erased, it is not longer counted as dirty_space 8241da177e4SLinus Torvalds * but it is counted in c->nr_erasing_blocks, so we add it and subtract it 8251da177e4SLinus Torvalds * with c->nr_erasing_blocks * c->sector_size again. 8261da177e4SLinus Torvalds * Blocks on erasable_list are counted as dirty_size, but not in c->nr_erasing_blocks 8271da177e4SLinus Torvalds * This helps us to force gc and pick eventually a clean block to spread the load. 8281da177e4SLinus Torvalds */ 8291da177e4SLinus Torvalds dirty = c->dirty_size + c->erasing_size - c->nr_erasing_blocks * c->sector_size; 8301da177e4SLinus Torvalds 8311da177e4SLinus Torvalds if (c->nr_free_blocks + c->nr_erasing_blocks < c->resv_blocks_gctrigger && 8321da177e4SLinus Torvalds (dirty > c->nospc_dirty_size)) 8331da177e4SLinus Torvalds ret = 1; 8341da177e4SLinus Torvalds 8351da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_thread_should_wake(): nr_free_blocks %d, nr_erasing_blocks %d, dirty_size 0x%x: %s\n", 8361da177e4SLinus Torvalds c->nr_free_blocks, c->nr_erasing_blocks, c->dirty_size, ret?"yes":"no")); 8371da177e4SLinus Torvalds 8381da177e4SLinus Torvalds return ret; 8391da177e4SLinus Torvalds } 840