11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * JFFS2 -- Journalling Flash File System, Version 2. 31da177e4SLinus Torvalds * 4c00c310eSDavid Woodhouse * Copyright © 2001-2007 Red Hat, Inc. 56088c058SDavid Woodhouse * Copyright © 2004-2010 David Woodhouse <dwmw2@infradead.org> 61da177e4SLinus Torvalds * 71da177e4SLinus Torvalds * Created by David Woodhouse <dwmw2@infradead.org> 81da177e4SLinus Torvalds * 91da177e4SLinus Torvalds * For licensing information, see the file 'LICENCE' in this directory. 101da177e4SLinus Torvalds * 111da177e4SLinus Torvalds */ 121da177e4SLinus Torvalds 131da177e4SLinus Torvalds #include <linux/kernel.h> 141da177e4SLinus Torvalds #include <linux/mtd/mtd.h> 151da177e4SLinus Torvalds #include <linux/slab.h> 161da177e4SLinus Torvalds #include <linux/pagemap.h> 171da177e4SLinus Torvalds #include <linux/crc32.h> 181da177e4SLinus Torvalds #include <linux/compiler.h> 191da177e4SLinus Torvalds #include <linux/stat.h> 201da177e4SLinus Torvalds #include "nodelist.h" 211da177e4SLinus Torvalds #include "compr.h" 221da177e4SLinus Torvalds 231da177e4SLinus Torvalds static int jffs2_garbage_collect_pristine(struct jffs2_sb_info *c, 241da177e4SLinus Torvalds struct jffs2_inode_cache *ic, 251da177e4SLinus Torvalds struct jffs2_raw_node_ref *raw); 261da177e4SLinus Torvalds static int jffs2_garbage_collect_metadata(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 271da177e4SLinus Torvalds struct jffs2_inode_info *f, struct jffs2_full_dnode *fd); 281da177e4SLinus Torvalds static int jffs2_garbage_collect_dirent(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 291da177e4SLinus Torvalds struct jffs2_inode_info *f, struct jffs2_full_dirent *fd); 301da177e4SLinus Torvalds static int jffs2_garbage_collect_deletion_dirent(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 311da177e4SLinus Torvalds struct jffs2_inode_info *f, struct jffs2_full_dirent *fd); 321da177e4SLinus Torvalds static int jffs2_garbage_collect_hole(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 331da177e4SLinus Torvalds struct jffs2_inode_info *f, struct jffs2_full_dnode *fn, 341da177e4SLinus Torvalds uint32_t start, uint32_t end); 351da177e4SLinus Torvalds static int jffs2_garbage_collect_dnode(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 361da177e4SLinus Torvalds struct jffs2_inode_info *f, struct jffs2_full_dnode *fn, 371da177e4SLinus Torvalds uint32_t start, uint32_t end); 381da177e4SLinus Torvalds static int jffs2_garbage_collect_live(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 391da177e4SLinus Torvalds struct jffs2_raw_node_ref *raw, struct jffs2_inode_info *f); 401da177e4SLinus Torvalds 411da177e4SLinus Torvalds /* Called with erase_completion_lock held */ 421da177e4SLinus Torvalds static struct jffs2_eraseblock *jffs2_find_gc_block(struct jffs2_sb_info *c) 431da177e4SLinus Torvalds { 441da177e4SLinus Torvalds struct jffs2_eraseblock *ret; 451da177e4SLinus Torvalds struct list_head *nextlist = NULL; 461da177e4SLinus Torvalds int n = jiffies % 128; 471da177e4SLinus Torvalds 481da177e4SLinus Torvalds /* Pick an eraseblock to garbage collect next. This is where we'll 491da177e4SLinus Torvalds put the clever wear-levelling algorithms. Eventually. */ 501da177e4SLinus Torvalds /* We possibly want to favour the dirtier blocks more when the 511da177e4SLinus Torvalds number of free blocks is low. */ 52a42163d7SArtem B. Bityuckiy again: 531da177e4SLinus Torvalds if (!list_empty(&c->bad_used_list) && c->nr_free_blocks > c->resv_blocks_gcbad) { 541da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Picking block from bad_used_list to GC next\n")); 551da177e4SLinus Torvalds nextlist = &c->bad_used_list; 561da177e4SLinus Torvalds } else if (n < 50 && !list_empty(&c->erasable_list)) { 571da177e4SLinus Torvalds /* Note that most of them will have gone directly to be erased. 581da177e4SLinus Torvalds So don't favour the erasable_list _too_ much. */ 591da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Picking block from erasable_list to GC next\n")); 601da177e4SLinus Torvalds nextlist = &c->erasable_list; 611da177e4SLinus Torvalds } else if (n < 110 && !list_empty(&c->very_dirty_list)) { 621da177e4SLinus Torvalds /* Most of the time, pick one off the very_dirty list */ 631da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Picking block from very_dirty_list to GC next\n")); 641da177e4SLinus Torvalds nextlist = &c->very_dirty_list; 651da177e4SLinus Torvalds } else if (n < 126 && !list_empty(&c->dirty_list)) { 661da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Picking block from dirty_list to GC next\n")); 671da177e4SLinus Torvalds nextlist = &c->dirty_list; 681da177e4SLinus Torvalds } else if (!list_empty(&c->clean_list)) { 691da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Picking block from clean_list to GC next\n")); 701da177e4SLinus Torvalds nextlist = &c->clean_list; 711da177e4SLinus Torvalds } else if (!list_empty(&c->dirty_list)) { 721da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Picking block from dirty_list to GC next (clean_list was empty)\n")); 731da177e4SLinus Torvalds 741da177e4SLinus Torvalds nextlist = &c->dirty_list; 751da177e4SLinus Torvalds } else if (!list_empty(&c->very_dirty_list)) { 761da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Picking block from very_dirty_list to GC next (clean_list and dirty_list were empty)\n")); 771da177e4SLinus Torvalds nextlist = &c->very_dirty_list; 781da177e4SLinus Torvalds } else if (!list_empty(&c->erasable_list)) { 791da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Picking block from erasable_list to GC next (clean_list and {very_,}dirty_list were empty)\n")); 801da177e4SLinus Torvalds 811da177e4SLinus Torvalds nextlist = &c->erasable_list; 82a42163d7SArtem B. Bityuckiy } else if (!list_empty(&c->erasable_pending_wbuf_list)) { 83a42163d7SArtem B. Bityuckiy /* There are blocks are wating for the wbuf sync */ 84a42163d7SArtem B. Bityuckiy D1(printk(KERN_DEBUG "Synching wbuf in order to reuse erasable_pending_wbuf_list blocks\n")); 853cceb9f6SArtem B. Bityuckiy spin_unlock(&c->erase_completion_lock); 86a42163d7SArtem B. Bityuckiy jffs2_flush_wbuf_pad(c); 873cceb9f6SArtem B. Bityuckiy spin_lock(&c->erase_completion_lock); 88a42163d7SArtem B. Bityuckiy goto again; 891da177e4SLinus Torvalds } else { 901da177e4SLinus Torvalds /* Eep. All were empty */ 911da177e4SLinus Torvalds D1(printk(KERN_NOTICE "jffs2: No clean, dirty _or_ erasable blocks to GC from! Where are they all?\n")); 921da177e4SLinus Torvalds return NULL; 931da177e4SLinus Torvalds } 941da177e4SLinus Torvalds 951da177e4SLinus Torvalds ret = list_entry(nextlist->next, struct jffs2_eraseblock, list); 961da177e4SLinus Torvalds list_del(&ret->list); 971da177e4SLinus Torvalds c->gcblock = ret; 981da177e4SLinus Torvalds ret->gc_node = ret->first_node; 991da177e4SLinus Torvalds if (!ret->gc_node) { 1001da177e4SLinus Torvalds printk(KERN_WARNING "Eep. ret->gc_node for block at 0x%08x is NULL\n", ret->offset); 1011da177e4SLinus Torvalds BUG(); 1021da177e4SLinus Torvalds } 1031da177e4SLinus Torvalds 1041da177e4SLinus Torvalds /* Have we accidentally picked a clean block with wasted space ? */ 1051da177e4SLinus Torvalds if (ret->wasted_size) { 1061da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Converting wasted_size %08x to dirty_size\n", ret->wasted_size)); 1071da177e4SLinus Torvalds ret->dirty_size += ret->wasted_size; 1081da177e4SLinus Torvalds c->wasted_size -= ret->wasted_size; 1091da177e4SLinus Torvalds c->dirty_size += ret->wasted_size; 1101da177e4SLinus Torvalds ret->wasted_size = 0; 1111da177e4SLinus Torvalds } 1121da177e4SLinus Torvalds 1131da177e4SLinus Torvalds return ret; 1141da177e4SLinus Torvalds } 1151da177e4SLinus Torvalds 1161da177e4SLinus Torvalds /* jffs2_garbage_collect_pass 1171da177e4SLinus Torvalds * Make a single attempt to progress GC. Move one node, and possibly 1181da177e4SLinus Torvalds * start erasing one eraseblock. 1191da177e4SLinus Torvalds */ 1201da177e4SLinus Torvalds int jffs2_garbage_collect_pass(struct jffs2_sb_info *c) 1211da177e4SLinus Torvalds { 1221da177e4SLinus Torvalds struct jffs2_inode_info *f; 1231da177e4SLinus Torvalds struct jffs2_inode_cache *ic; 1241da177e4SLinus Torvalds struct jffs2_eraseblock *jeb; 1251da177e4SLinus Torvalds struct jffs2_raw_node_ref *raw; 1262665ea84SDavid Woodhouse uint32_t gcblock_dirty; 1271da177e4SLinus Torvalds int ret = 0, inum, nlink; 128aa98d7cfSKaiGai Kohei int xattr = 0; 1291da177e4SLinus Torvalds 130ced22070SDavid Woodhouse if (mutex_lock_interruptible(&c->alloc_sem)) 1311da177e4SLinus Torvalds return -EINTR; 1321da177e4SLinus Torvalds 1331da177e4SLinus Torvalds for (;;) { 1341da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 1351da177e4SLinus Torvalds if (!c->unchecked_size) 1361da177e4SLinus Torvalds break; 1371da177e4SLinus Torvalds 1381da177e4SLinus Torvalds /* We can't start doing GC yet. We haven't finished checking 1391da177e4SLinus Torvalds the node CRCs etc. Do it now. */ 1401da177e4SLinus Torvalds 1411da177e4SLinus Torvalds /* checked_ino is protected by the alloc_sem */ 142aa98d7cfSKaiGai Kohei if (c->checked_ino > c->highest_ino && xattr) { 1431da177e4SLinus Torvalds printk(KERN_CRIT "Checked all inodes but still 0x%x bytes of unchecked space?\n", 1441da177e4SLinus Torvalds c->unchecked_size); 145e0c8e42fSArtem B. Bityutskiy jffs2_dbg_dump_block_lists_nolock(c); 1461da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 147ced22070SDavid Woodhouse mutex_unlock(&c->alloc_sem); 14844b998e1SDavid Woodhouse return -ENOSPC; 1491da177e4SLinus Torvalds } 1501da177e4SLinus Torvalds 1511da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 1521da177e4SLinus Torvalds 153aa98d7cfSKaiGai Kohei if (!xattr) 154aa98d7cfSKaiGai Kohei xattr = jffs2_verify_xattr(c); 155aa98d7cfSKaiGai Kohei 1561da177e4SLinus Torvalds spin_lock(&c->inocache_lock); 1571da177e4SLinus Torvalds 1581da177e4SLinus Torvalds ic = jffs2_get_ino_cache(c, c->checked_ino++); 1591da177e4SLinus Torvalds 1601da177e4SLinus Torvalds if (!ic) { 1611da177e4SLinus Torvalds spin_unlock(&c->inocache_lock); 1621da177e4SLinus Torvalds continue; 1631da177e4SLinus Torvalds } 1641da177e4SLinus Torvalds 16527c72b04SDavid Woodhouse if (!ic->pino_nlink) { 16627c72b04SDavid Woodhouse D1(printk(KERN_DEBUG "Skipping check of ino #%d with nlink/pino zero\n", 1671da177e4SLinus Torvalds ic->ino)); 1681da177e4SLinus Torvalds spin_unlock(&c->inocache_lock); 169355ed4e1SKaiGai Kohei jffs2_xattr_delete_inode(c, ic); 1701da177e4SLinus Torvalds continue; 1711da177e4SLinus Torvalds } 1721da177e4SLinus Torvalds switch(ic->state) { 1731da177e4SLinus Torvalds case INO_STATE_CHECKEDABSENT: 1741da177e4SLinus Torvalds case INO_STATE_PRESENT: 1751da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Skipping ino #%u already checked\n", ic->ino)); 1761da177e4SLinus Torvalds spin_unlock(&c->inocache_lock); 1771da177e4SLinus Torvalds continue; 1781da177e4SLinus Torvalds 1791da177e4SLinus Torvalds case INO_STATE_GC: 1801da177e4SLinus Torvalds case INO_STATE_CHECKING: 1811da177e4SLinus Torvalds printk(KERN_WARNING "Inode #%u is in state %d during CRC check phase!\n", ic->ino, ic->state); 1821da177e4SLinus Torvalds spin_unlock(&c->inocache_lock); 1831da177e4SLinus Torvalds BUG(); 1841da177e4SLinus Torvalds 1851da177e4SLinus Torvalds case INO_STATE_READING: 1861da177e4SLinus Torvalds /* We need to wait for it to finish, lest we move on 1871da177e4SLinus Torvalds and trigger the BUG() above while we haven't yet 1881da177e4SLinus Torvalds finished checking all its nodes */ 1891da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Waiting for ino #%u to finish reading\n", ic->ino)); 190d96fb997SDavid Woodhouse /* We need to come back again for the _same_ inode. We've 191d96fb997SDavid Woodhouse made no progress in this case, but that should be OK */ 192d96fb997SDavid Woodhouse c->checked_ino--; 193d96fb997SDavid Woodhouse 194ced22070SDavid Woodhouse mutex_unlock(&c->alloc_sem); 1951da177e4SLinus Torvalds sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock); 1961da177e4SLinus Torvalds return 0; 1971da177e4SLinus Torvalds 1981da177e4SLinus Torvalds default: 1991da177e4SLinus Torvalds BUG(); 2001da177e4SLinus Torvalds 2011da177e4SLinus Torvalds case INO_STATE_UNCHECKED: 2021da177e4SLinus Torvalds ; 2031da177e4SLinus Torvalds } 2041da177e4SLinus Torvalds ic->state = INO_STATE_CHECKING; 2051da177e4SLinus Torvalds spin_unlock(&c->inocache_lock); 2061da177e4SLinus Torvalds 2071da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_garbage_collect_pass() triggering inode scan of ino#%u\n", ic->ino)); 2081da177e4SLinus Torvalds 2091da177e4SLinus Torvalds ret = jffs2_do_crccheck_inode(c, ic); 2101da177e4SLinus Torvalds if (ret) 2111da177e4SLinus Torvalds printk(KERN_WARNING "Returned error for crccheck of ino #%u. Expect badness...\n", ic->ino); 2121da177e4SLinus Torvalds 2131da177e4SLinus Torvalds jffs2_set_inocache_state(c, ic, INO_STATE_CHECKEDABSENT); 214ced22070SDavid Woodhouse mutex_unlock(&c->alloc_sem); 2151da177e4SLinus Torvalds return ret; 2161da177e4SLinus Torvalds } 2171da177e4SLinus Torvalds 2180717bf84SDavid Woodhouse /* If there are any blocks which need erasing, erase them now */ 2190717bf84SDavid Woodhouse if (!list_empty(&c->erase_complete_list) || 2200717bf84SDavid Woodhouse !list_empty(&c->erase_pending_list)) { 2210717bf84SDavid Woodhouse spin_unlock(&c->erase_completion_lock); 2220717bf84SDavid Woodhouse D1(printk(KERN_DEBUG "jffs2_garbage_collect_pass() erasing pending blocks\n")); 2230717bf84SDavid Woodhouse if (jffs2_erase_pending_blocks(c, 1)) { 2240717bf84SDavid Woodhouse mutex_unlock(&c->alloc_sem); 2250717bf84SDavid Woodhouse return 0; 2260717bf84SDavid Woodhouse } 2270717bf84SDavid Woodhouse D1(printk(KERN_DEBUG "No progress from erasing blocks; doing GC anyway\n")); 2280717bf84SDavid Woodhouse spin_lock(&c->erase_completion_lock); 2290717bf84SDavid Woodhouse } 2300717bf84SDavid Woodhouse 2311da177e4SLinus Torvalds /* First, work out which block we're garbage-collecting */ 2321da177e4SLinus Torvalds jeb = c->gcblock; 2331da177e4SLinus Torvalds 2341da177e4SLinus Torvalds if (!jeb) 2351da177e4SLinus Torvalds jeb = jffs2_find_gc_block(c); 2361da177e4SLinus Torvalds 2371da177e4SLinus Torvalds if (!jeb) { 238422b1202SDavid Woodhouse /* Couldn't find a free block. But maybe we can just erase one and make 'progress'? */ 2390717bf84SDavid Woodhouse if (c->nr_erasing_blocks) { 240422b1202SDavid Woodhouse spin_unlock(&c->erase_completion_lock); 241422b1202SDavid Woodhouse mutex_unlock(&c->alloc_sem); 242422b1202SDavid Woodhouse return -EAGAIN; 243422b1202SDavid Woodhouse } 2441da177e4SLinus Torvalds D1(printk(KERN_NOTICE "jffs2: Couldn't find erase block to garbage collect!\n")); 2451da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 246ced22070SDavid Woodhouse mutex_unlock(&c->alloc_sem); 2471da177e4SLinus Torvalds return -EIO; 2481da177e4SLinus Torvalds } 2491da177e4SLinus Torvalds 2501da177e4SLinus Torvalds D1(printk(KERN_DEBUG "GC from block %08x, used_size %08x, dirty_size %08x, free_size %08x\n", jeb->offset, jeb->used_size, jeb->dirty_size, jeb->free_size)); 2511da177e4SLinus Torvalds D1(if (c->nextblock) 2521da177e4SLinus Torvalds printk(KERN_DEBUG "Nextblock at %08x, used_size %08x, dirty_size %08x, wasted_size %08x, free_size %08x\n", c->nextblock->offset, c->nextblock->used_size, c->nextblock->dirty_size, c->nextblock->wasted_size, c->nextblock->free_size)); 2531da177e4SLinus Torvalds 2541da177e4SLinus Torvalds if (!jeb->used_size) { 255ced22070SDavid Woodhouse mutex_unlock(&c->alloc_sem); 2561da177e4SLinus Torvalds goto eraseit; 2571da177e4SLinus Torvalds } 2581da177e4SLinus Torvalds 2591da177e4SLinus Torvalds raw = jeb->gc_node; 2602665ea84SDavid Woodhouse gcblock_dirty = jeb->dirty_size; 2611da177e4SLinus Torvalds 2621da177e4SLinus Torvalds while(ref_obsolete(raw)) { 2631da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Node at 0x%08x is obsolete... skipping\n", ref_offset(raw))); 26499988f7bSDavid Woodhouse raw = ref_next(raw); 2651da177e4SLinus Torvalds if (unlikely(!raw)) { 2661da177e4SLinus Torvalds printk(KERN_WARNING "eep. End of raw list while still supposedly nodes to GC\n"); 2671da177e4SLinus Torvalds printk(KERN_WARNING "erase block at 0x%08x. free_size 0x%08x, dirty_size 0x%08x, used_size 0x%08x\n", 2681da177e4SLinus Torvalds jeb->offset, jeb->free_size, jeb->dirty_size, jeb->used_size); 2691da177e4SLinus Torvalds jeb->gc_node = raw; 2701da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 271ced22070SDavid Woodhouse mutex_unlock(&c->alloc_sem); 2721da177e4SLinus Torvalds BUG(); 2731da177e4SLinus Torvalds } 2741da177e4SLinus Torvalds } 2751da177e4SLinus Torvalds jeb->gc_node = raw; 2761da177e4SLinus Torvalds 2771da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Going to garbage collect node at 0x%08x\n", ref_offset(raw))); 2781da177e4SLinus Torvalds 2791da177e4SLinus Torvalds if (!raw->next_in_ino) { 2801da177e4SLinus Torvalds /* Inode-less node. Clean marker, snapshot or something like that */ 2811da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 2826171586aSDavid Woodhouse if (ref_flags(raw) == REF_PRISTINE) { 2836171586aSDavid Woodhouse /* It's an unknown node with JFFS2_FEATURE_RWCOMPAT_COPY */ 2846171586aSDavid Woodhouse jffs2_garbage_collect_pristine(c, NULL, raw); 2856171586aSDavid Woodhouse } else { 2866171586aSDavid Woodhouse /* Just mark it obsolete */ 2871da177e4SLinus Torvalds jffs2_mark_node_obsolete(c, raw); 2886171586aSDavid Woodhouse } 289ced22070SDavid Woodhouse mutex_unlock(&c->alloc_sem); 2901da177e4SLinus Torvalds goto eraseit_lock; 2911da177e4SLinus Torvalds } 2921da177e4SLinus Torvalds 2931da177e4SLinus Torvalds ic = jffs2_raw_ref_to_ic(raw); 2941da177e4SLinus Torvalds 295084702e0SKaiGai Kohei #ifdef CONFIG_JFFS2_FS_XATTR 296aa98d7cfSKaiGai Kohei /* When 'ic' refers xattr_datum/xattr_ref, this node is GCed as xattr. 297084702e0SKaiGai Kohei * We can decide whether this node is inode or xattr by ic->class. */ 298084702e0SKaiGai Kohei if (ic->class == RAWNODE_CLASS_XATTR_DATUM 299084702e0SKaiGai Kohei || ic->class == RAWNODE_CLASS_XATTR_REF) { 300084702e0SKaiGai Kohei spin_unlock(&c->erase_completion_lock); 301084702e0SKaiGai Kohei 302084702e0SKaiGai Kohei if (ic->class == RAWNODE_CLASS_XATTR_DATUM) { 303c9f700f8SKaiGai Kohei ret = jffs2_garbage_collect_xattr_datum(c, (struct jffs2_xattr_datum *)ic, raw); 304084702e0SKaiGai Kohei } else { 305c9f700f8SKaiGai Kohei ret = jffs2_garbage_collect_xattr_ref(c, (struct jffs2_xattr_ref *)ic, raw); 306084702e0SKaiGai Kohei } 3072665ea84SDavid Woodhouse goto test_gcnode; 308084702e0SKaiGai Kohei } 309084702e0SKaiGai Kohei #endif 310aa98d7cfSKaiGai Kohei 3111da177e4SLinus Torvalds /* We need to hold the inocache. Either the erase_completion_lock or 3121da177e4SLinus Torvalds the inocache_lock are sufficient; we trade down since the inocache_lock 3131da177e4SLinus Torvalds causes less contention. */ 3141da177e4SLinus Torvalds spin_lock(&c->inocache_lock); 3151da177e4SLinus Torvalds 3161da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 3171da177e4SLinus Torvalds 3181da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_garbage_collect_pass collecting from block @0x%08x. Node @0x%08x(%d), ino #%u\n", jeb->offset, ref_offset(raw), ref_flags(raw), ic->ino)); 3191da177e4SLinus Torvalds 3201da177e4SLinus Torvalds /* Three possibilities: 3211da177e4SLinus Torvalds 1. Inode is already in-core. We must iget it and do proper 3221da177e4SLinus Torvalds updating to its fragtree, etc. 3231da177e4SLinus Torvalds 2. Inode is not in-core, node is REF_PRISTINE. We lock the 3241da177e4SLinus Torvalds inocache to prevent a read_inode(), copy the node intact. 3251da177e4SLinus Torvalds 3. Inode is not in-core, node is not pristine. We must iget() 3261da177e4SLinus Torvalds and take the slow path. 3271da177e4SLinus Torvalds */ 3281da177e4SLinus Torvalds 3291da177e4SLinus Torvalds switch(ic->state) { 3301da177e4SLinus Torvalds case INO_STATE_CHECKEDABSENT: 3311da177e4SLinus Torvalds /* It's been checked, but it's not currently in-core. 3321da177e4SLinus Torvalds We can just copy any pristine nodes, but have 3331da177e4SLinus Torvalds to prevent anyone else from doing read_inode() while 3341da177e4SLinus Torvalds we're at it, so we set the state accordingly */ 3351da177e4SLinus Torvalds if (ref_flags(raw) == REF_PRISTINE) 3361da177e4SLinus Torvalds ic->state = INO_STATE_GC; 3371da177e4SLinus Torvalds else { 3381da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Ino #%u is absent but node not REF_PRISTINE. Reading.\n", 3391da177e4SLinus Torvalds ic->ino)); 3401da177e4SLinus Torvalds } 3411da177e4SLinus Torvalds break; 3421da177e4SLinus Torvalds 3431da177e4SLinus Torvalds case INO_STATE_PRESENT: 3441da177e4SLinus Torvalds /* It's in-core. GC must iget() it. */ 3451da177e4SLinus Torvalds break; 3461da177e4SLinus Torvalds 3471da177e4SLinus Torvalds case INO_STATE_UNCHECKED: 3481da177e4SLinus Torvalds case INO_STATE_CHECKING: 3491da177e4SLinus Torvalds case INO_STATE_GC: 3501da177e4SLinus Torvalds /* Should never happen. We should have finished checking 3511da177e4SLinus Torvalds by the time we actually start doing any GC, and since 3521da177e4SLinus Torvalds we're holding the alloc_sem, no other garbage collection 3531da177e4SLinus Torvalds can happen. 3541da177e4SLinus Torvalds */ 3551da177e4SLinus Torvalds printk(KERN_CRIT "Inode #%u already in state %d in jffs2_garbage_collect_pass()!\n", 3561da177e4SLinus Torvalds ic->ino, ic->state); 357ced22070SDavid Woodhouse mutex_unlock(&c->alloc_sem); 3581da177e4SLinus Torvalds spin_unlock(&c->inocache_lock); 3591da177e4SLinus Torvalds BUG(); 3601da177e4SLinus Torvalds 3611da177e4SLinus Torvalds case INO_STATE_READING: 3621da177e4SLinus Torvalds /* Someone's currently trying to read it. We must wait for 3631da177e4SLinus Torvalds them to finish and then go through the full iget() route 3641da177e4SLinus Torvalds to do the GC. However, sometimes read_inode() needs to get 3651da177e4SLinus Torvalds the alloc_sem() (for marking nodes invalid) so we must 3661da177e4SLinus Torvalds drop the alloc_sem before sleeping. */ 3671da177e4SLinus Torvalds 368ced22070SDavid Woodhouse mutex_unlock(&c->alloc_sem); 3691da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_garbage_collect_pass() waiting for ino #%u in state %d\n", 3701da177e4SLinus Torvalds ic->ino, ic->state)); 3711da177e4SLinus Torvalds sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock); 3721da177e4SLinus Torvalds /* And because we dropped the alloc_sem we must start again from the 3731da177e4SLinus Torvalds beginning. Ponder chance of livelock here -- we're returning success 3741da177e4SLinus Torvalds without actually making any progress. 3751da177e4SLinus Torvalds 3761da177e4SLinus Torvalds Q: What are the chances that the inode is back in INO_STATE_READING 3771da177e4SLinus Torvalds again by the time we next enter this function? And that this happens 3781da177e4SLinus Torvalds enough times to cause a real delay? 3791da177e4SLinus Torvalds 3801da177e4SLinus Torvalds A: Small enough that I don't care :) 3811da177e4SLinus Torvalds */ 3821da177e4SLinus Torvalds return 0; 3831da177e4SLinus Torvalds } 3841da177e4SLinus Torvalds 3851da177e4SLinus Torvalds /* OK. Now if the inode is in state INO_STATE_GC, we are going to copy the 3861da177e4SLinus Torvalds node intact, and we don't have to muck about with the fragtree etc. 3871da177e4SLinus Torvalds because we know it's not in-core. If it _was_ in-core, we go through 3881da177e4SLinus Torvalds all the iget() crap anyway */ 3891da177e4SLinus Torvalds 3901da177e4SLinus Torvalds if (ic->state == INO_STATE_GC) { 3911da177e4SLinus Torvalds spin_unlock(&c->inocache_lock); 3921da177e4SLinus Torvalds 3931da177e4SLinus Torvalds ret = jffs2_garbage_collect_pristine(c, ic, raw); 3941da177e4SLinus Torvalds 3951da177e4SLinus Torvalds spin_lock(&c->inocache_lock); 3961da177e4SLinus Torvalds ic->state = INO_STATE_CHECKEDABSENT; 3971da177e4SLinus Torvalds wake_up(&c->inocache_wq); 3981da177e4SLinus Torvalds 3991da177e4SLinus Torvalds if (ret != -EBADFD) { 4001da177e4SLinus Torvalds spin_unlock(&c->inocache_lock); 4012665ea84SDavid Woodhouse goto test_gcnode; 4021da177e4SLinus Torvalds } 4031da177e4SLinus Torvalds 4041da177e4SLinus Torvalds /* Fall through if it wanted us to, with inocache_lock held */ 4051da177e4SLinus Torvalds } 4061da177e4SLinus Torvalds 4071da177e4SLinus Torvalds /* Prevent the fairly unlikely race where the gcblock is 4081da177e4SLinus Torvalds entirely obsoleted by the final close of a file which had 4091da177e4SLinus Torvalds the only valid nodes in the block, followed by erasure, 4101da177e4SLinus Torvalds followed by freeing of the ic because the erased block(s) 4111da177e4SLinus Torvalds held _all_ the nodes of that inode.... never been seen but 4121da177e4SLinus Torvalds it's vaguely possible. */ 4131da177e4SLinus Torvalds 4141da177e4SLinus Torvalds inum = ic->ino; 41527c72b04SDavid Woodhouse nlink = ic->pino_nlink; 4161da177e4SLinus Torvalds spin_unlock(&c->inocache_lock); 4171da177e4SLinus Torvalds 4181b690b48SDavid Woodhouse f = jffs2_gc_fetch_inode(c, inum, !nlink); 4191da177e4SLinus Torvalds if (IS_ERR(f)) { 4201da177e4SLinus Torvalds ret = PTR_ERR(f); 4211da177e4SLinus Torvalds goto release_sem; 4221da177e4SLinus Torvalds } 4231da177e4SLinus Torvalds if (!f) { 4241da177e4SLinus Torvalds ret = 0; 4251da177e4SLinus Torvalds goto release_sem; 4261da177e4SLinus Torvalds } 4271da177e4SLinus Torvalds 4281da177e4SLinus Torvalds ret = jffs2_garbage_collect_live(c, jeb, raw, f); 4291da177e4SLinus Torvalds 4301da177e4SLinus Torvalds jffs2_gc_release_inode(c, f); 4311da177e4SLinus Torvalds 4322665ea84SDavid Woodhouse test_gcnode: 4332665ea84SDavid Woodhouse if (jeb->dirty_size == gcblock_dirty && !ref_obsolete(jeb->gc_node)) { 4342665ea84SDavid Woodhouse /* Eep. This really should never happen. GC is broken */ 4352665ea84SDavid Woodhouse printk(KERN_ERR "Error garbage collecting node at %08x!\n", ref_offset(jeb->gc_node)); 4362665ea84SDavid Woodhouse ret = -ENOSPC; 4374fc8a607SDavid Woodhouse } 4381da177e4SLinus Torvalds release_sem: 439ced22070SDavid Woodhouse mutex_unlock(&c->alloc_sem); 4401da177e4SLinus Torvalds 4411da177e4SLinus Torvalds eraseit_lock: 4421da177e4SLinus Torvalds /* If we've finished this block, start it erasing */ 4431da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 4441da177e4SLinus Torvalds 4451da177e4SLinus Torvalds eraseit: 4461da177e4SLinus Torvalds if (c->gcblock && !c->gcblock->used_size) { 4471da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Block at 0x%08x completely obsoleted by GC. Moving to erase_pending_list\n", c->gcblock->offset)); 4481da177e4SLinus Torvalds /* We're GC'ing an empty block? */ 4491da177e4SLinus Torvalds list_add_tail(&c->gcblock->list, &c->erase_pending_list); 4501da177e4SLinus Torvalds c->gcblock = NULL; 4511da177e4SLinus Torvalds c->nr_erasing_blocks++; 452ae3b6ba0SDavid Woodhouse jffs2_garbage_collect_trigger(c); 4531da177e4SLinus Torvalds } 4541da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 4551da177e4SLinus Torvalds 4561da177e4SLinus Torvalds return ret; 4571da177e4SLinus Torvalds } 4581da177e4SLinus Torvalds 4591da177e4SLinus Torvalds static int jffs2_garbage_collect_live(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 4601da177e4SLinus Torvalds struct jffs2_raw_node_ref *raw, struct jffs2_inode_info *f) 4611da177e4SLinus Torvalds { 4621da177e4SLinus Torvalds struct jffs2_node_frag *frag; 4631da177e4SLinus Torvalds struct jffs2_full_dnode *fn = NULL; 4641da177e4SLinus Torvalds struct jffs2_full_dirent *fd; 4651da177e4SLinus Torvalds uint32_t start = 0, end = 0, nrfrags = 0; 4661da177e4SLinus Torvalds int ret = 0; 4671da177e4SLinus Torvalds 468ced22070SDavid Woodhouse mutex_lock(&f->sem); 4691da177e4SLinus Torvalds 4701da177e4SLinus Torvalds /* Now we have the lock for this inode. Check that it's still the one at the head 4711da177e4SLinus Torvalds of the list. */ 4721da177e4SLinus Torvalds 4731da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 4741da177e4SLinus Torvalds 4751da177e4SLinus Torvalds if (c->gcblock != jeb) { 4761da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 4771da177e4SLinus Torvalds D1(printk(KERN_DEBUG "GC block is no longer gcblock. Restart\n")); 4781da177e4SLinus Torvalds goto upnout; 4791da177e4SLinus Torvalds } 4801da177e4SLinus Torvalds if (ref_obsolete(raw)) { 4811da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 4821da177e4SLinus Torvalds D1(printk(KERN_DEBUG "node to be GC'd was obsoleted in the meantime.\n")); 4831da177e4SLinus Torvalds /* They'll call again */ 4841da177e4SLinus Torvalds goto upnout; 4851da177e4SLinus Torvalds } 4861da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 4871da177e4SLinus Torvalds 4881da177e4SLinus Torvalds /* OK. Looks safe. And nobody can get us now because we have the semaphore. Move the block */ 4891da177e4SLinus Torvalds if (f->metadata && f->metadata->raw == raw) { 4901da177e4SLinus Torvalds fn = f->metadata; 4911da177e4SLinus Torvalds ret = jffs2_garbage_collect_metadata(c, jeb, f, fn); 4921da177e4SLinus Torvalds goto upnout; 4931da177e4SLinus Torvalds } 4941da177e4SLinus Torvalds 4951da177e4SLinus Torvalds /* FIXME. Read node and do lookup? */ 4961da177e4SLinus Torvalds for (frag = frag_first(&f->fragtree); frag; frag = frag_next(frag)) { 4971da177e4SLinus Torvalds if (frag->node && frag->node->raw == raw) { 4981da177e4SLinus Torvalds fn = frag->node; 4991da177e4SLinus Torvalds end = frag->ofs + frag->size; 5001da177e4SLinus Torvalds if (!nrfrags++) 5011da177e4SLinus Torvalds start = frag->ofs; 5021da177e4SLinus Torvalds if (nrfrags == frag->node->frags) 5031da177e4SLinus Torvalds break; /* We've found them all */ 5041da177e4SLinus Torvalds } 5051da177e4SLinus Torvalds } 5061da177e4SLinus Torvalds if (fn) { 5071da177e4SLinus Torvalds if (ref_flags(raw) == REF_PRISTINE) { 5081da177e4SLinus Torvalds ret = jffs2_garbage_collect_pristine(c, f->inocache, raw); 5091da177e4SLinus Torvalds if (!ret) { 5101da177e4SLinus Torvalds /* Urgh. Return it sensibly. */ 5111da177e4SLinus Torvalds frag->node->raw = f->inocache->nodes; 5121da177e4SLinus Torvalds } 5131da177e4SLinus Torvalds if (ret != -EBADFD) 5141da177e4SLinus Torvalds goto upnout; 5151da177e4SLinus Torvalds } 5161da177e4SLinus Torvalds /* We found a datanode. Do the GC */ 5171da177e4SLinus Torvalds if((start >> PAGE_CACHE_SHIFT) < ((end-1) >> PAGE_CACHE_SHIFT)) { 5181da177e4SLinus Torvalds /* It crosses a page boundary. Therefore, it must be a hole. */ 5191da177e4SLinus Torvalds ret = jffs2_garbage_collect_hole(c, jeb, f, fn, start, end); 5201da177e4SLinus Torvalds } else { 5211da177e4SLinus Torvalds /* It could still be a hole. But we GC the page this way anyway */ 5221da177e4SLinus Torvalds ret = jffs2_garbage_collect_dnode(c, jeb, f, fn, start, end); 5231da177e4SLinus Torvalds } 5241da177e4SLinus Torvalds goto upnout; 5251da177e4SLinus Torvalds } 5261da177e4SLinus Torvalds 5271da177e4SLinus Torvalds /* Wasn't a dnode. Try dirent */ 5281da177e4SLinus Torvalds for (fd = f->dents; fd; fd=fd->next) { 5291da177e4SLinus Torvalds if (fd->raw == raw) 5301da177e4SLinus Torvalds break; 5311da177e4SLinus Torvalds } 5321da177e4SLinus Torvalds 5331da177e4SLinus Torvalds if (fd && fd->ino) { 5341da177e4SLinus Torvalds ret = jffs2_garbage_collect_dirent(c, jeb, f, fd); 5351da177e4SLinus Torvalds } else if (fd) { 5361da177e4SLinus Torvalds ret = jffs2_garbage_collect_deletion_dirent(c, jeb, f, fd); 5371da177e4SLinus Torvalds } else { 5381da177e4SLinus Torvalds printk(KERN_WARNING "Raw node at 0x%08x wasn't in node lists for ino #%u\n", 5391da177e4SLinus Torvalds ref_offset(raw), f->inocache->ino); 5401da177e4SLinus Torvalds if (ref_obsolete(raw)) { 5411da177e4SLinus Torvalds printk(KERN_WARNING "But it's obsolete so we don't mind too much\n"); 5421da177e4SLinus Torvalds } else { 543e0c8e42fSArtem B. Bityutskiy jffs2_dbg_dump_node(c, ref_offset(raw)); 544e0c8e42fSArtem B. Bityutskiy BUG(); 5451da177e4SLinus Torvalds } 5461da177e4SLinus Torvalds } 5471da177e4SLinus Torvalds upnout: 548ced22070SDavid Woodhouse mutex_unlock(&f->sem); 5491da177e4SLinus Torvalds 5501da177e4SLinus Torvalds return ret; 5511da177e4SLinus Torvalds } 5521da177e4SLinus Torvalds 5531da177e4SLinus Torvalds static int jffs2_garbage_collect_pristine(struct jffs2_sb_info *c, 5541da177e4SLinus Torvalds struct jffs2_inode_cache *ic, 5551da177e4SLinus Torvalds struct jffs2_raw_node_ref *raw) 5561da177e4SLinus Torvalds { 5571da177e4SLinus Torvalds union jffs2_node_union *node; 5581da177e4SLinus Torvalds size_t retlen; 5591da177e4SLinus Torvalds int ret; 5601da177e4SLinus Torvalds uint32_t phys_ofs, alloclen; 5611da177e4SLinus Torvalds uint32_t crc, rawlen; 5621da177e4SLinus Torvalds int retried = 0; 5631da177e4SLinus Torvalds 5641da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Going to GC REF_PRISTINE node at 0x%08x\n", ref_offset(raw))); 5651da177e4SLinus Torvalds 5666171586aSDavid Woodhouse alloclen = rawlen = ref_totlen(c, c->gcblock, raw); 5671da177e4SLinus Torvalds 5681da177e4SLinus Torvalds /* Ask for a small amount of space (or the totlen if smaller) because we 5691da177e4SLinus Torvalds don't want to force wastage of the end of a block if splitting would 5701da177e4SLinus Torvalds work. */ 5716171586aSDavid Woodhouse if (ic && alloclen > sizeof(struct jffs2_raw_inode) + JFFS2_MIN_DATA_LEN) 5726171586aSDavid Woodhouse alloclen = sizeof(struct jffs2_raw_inode) + JFFS2_MIN_DATA_LEN; 5736171586aSDavid Woodhouse 5749fe4854cSDavid Woodhouse ret = jffs2_reserve_space_gc(c, alloclen, &alloclen, rawlen); 5756171586aSDavid Woodhouse /* 'rawlen' is not the exact summary size; it is only an upper estimation */ 576e631ddbaSFerenc Havasi 5771da177e4SLinus Torvalds if (ret) 5781da177e4SLinus Torvalds return ret; 5791da177e4SLinus Torvalds 5801da177e4SLinus Torvalds if (alloclen < rawlen) { 5811da177e4SLinus Torvalds /* Doesn't fit untouched. We'll go the old route and split it */ 5821da177e4SLinus Torvalds return -EBADFD; 5831da177e4SLinus Torvalds } 5841da177e4SLinus Torvalds 5851da177e4SLinus Torvalds node = kmalloc(rawlen, GFP_KERNEL); 5861da177e4SLinus Torvalds if (!node) 5871da177e4SLinus Torvalds return -ENOMEM; 5881da177e4SLinus Torvalds 5891da177e4SLinus Torvalds ret = jffs2_flash_read(c, ref_offset(raw), rawlen, &retlen, (char *)node); 5901da177e4SLinus Torvalds if (!ret && retlen != rawlen) 5911da177e4SLinus Torvalds ret = -EIO; 5921da177e4SLinus Torvalds if (ret) 5931da177e4SLinus Torvalds goto out_node; 5941da177e4SLinus Torvalds 5951da177e4SLinus Torvalds crc = crc32(0, node, sizeof(struct jffs2_unknown_node)-4); 5961da177e4SLinus Torvalds if (je32_to_cpu(node->u.hdr_crc) != crc) { 5971da177e4SLinus Torvalds printk(KERN_WARNING "Header CRC failed on REF_PRISTINE node at 0x%08x: Read 0x%08x, calculated 0x%08x\n", 5981da177e4SLinus Torvalds ref_offset(raw), je32_to_cpu(node->u.hdr_crc), crc); 5991da177e4SLinus Torvalds goto bail; 6001da177e4SLinus Torvalds } 6011da177e4SLinus Torvalds 6021da177e4SLinus Torvalds switch(je16_to_cpu(node->u.nodetype)) { 6031da177e4SLinus Torvalds case JFFS2_NODETYPE_INODE: 6041da177e4SLinus Torvalds crc = crc32(0, node, sizeof(node->i)-8); 6051da177e4SLinus Torvalds if (je32_to_cpu(node->i.node_crc) != crc) { 6061da177e4SLinus Torvalds printk(KERN_WARNING "Node CRC failed on REF_PRISTINE data node at 0x%08x: Read 0x%08x, calculated 0x%08x\n", 6071da177e4SLinus Torvalds ref_offset(raw), je32_to_cpu(node->i.node_crc), crc); 6081da177e4SLinus Torvalds goto bail; 6091da177e4SLinus Torvalds } 6101da177e4SLinus Torvalds 6111da177e4SLinus Torvalds if (je32_to_cpu(node->i.dsize)) { 6121da177e4SLinus Torvalds crc = crc32(0, node->i.data, je32_to_cpu(node->i.csize)); 6131da177e4SLinus Torvalds if (je32_to_cpu(node->i.data_crc) != crc) { 6141da177e4SLinus Torvalds printk(KERN_WARNING "Data CRC failed on REF_PRISTINE data node at 0x%08x: Read 0x%08x, calculated 0x%08x\n", 6151da177e4SLinus Torvalds ref_offset(raw), je32_to_cpu(node->i.data_crc), crc); 6161da177e4SLinus Torvalds goto bail; 6171da177e4SLinus Torvalds } 6181da177e4SLinus Torvalds } 6191da177e4SLinus Torvalds break; 6201da177e4SLinus Torvalds 6211da177e4SLinus Torvalds case JFFS2_NODETYPE_DIRENT: 6221da177e4SLinus Torvalds crc = crc32(0, node, sizeof(node->d)-8); 6231da177e4SLinus Torvalds if (je32_to_cpu(node->d.node_crc) != crc) { 6241da177e4SLinus Torvalds printk(KERN_WARNING "Node CRC failed on REF_PRISTINE dirent node at 0x%08x: Read 0x%08x, calculated 0x%08x\n", 6251da177e4SLinus Torvalds ref_offset(raw), je32_to_cpu(node->d.node_crc), crc); 6261da177e4SLinus Torvalds goto bail; 6271da177e4SLinus Torvalds } 6281da177e4SLinus Torvalds 629b534e70cSDavid Woodhouse if (strnlen(node->d.name, node->d.nsize) != node->d.nsize) { 630b534e70cSDavid Woodhouse printk(KERN_WARNING "Name in dirent node at 0x%08x contains zeroes\n", ref_offset(raw)); 631b534e70cSDavid Woodhouse goto bail; 632b534e70cSDavid Woodhouse } 633b534e70cSDavid Woodhouse 6341da177e4SLinus Torvalds if (node->d.nsize) { 6351da177e4SLinus Torvalds crc = crc32(0, node->d.name, node->d.nsize); 6361da177e4SLinus Torvalds if (je32_to_cpu(node->d.name_crc) != crc) { 637b534e70cSDavid Woodhouse printk(KERN_WARNING "Name CRC failed on REF_PRISTINE dirent node at 0x%08x: Read 0x%08x, calculated 0x%08x\n", 6381da177e4SLinus Torvalds ref_offset(raw), je32_to_cpu(node->d.name_crc), crc); 6391da177e4SLinus Torvalds goto bail; 6401da177e4SLinus Torvalds } 6411da177e4SLinus Torvalds } 6421da177e4SLinus Torvalds break; 6431da177e4SLinus Torvalds default: 6446171586aSDavid Woodhouse /* If it's inode-less, we don't _know_ what it is. Just copy it intact */ 6456171586aSDavid Woodhouse if (ic) { 6461da177e4SLinus Torvalds printk(KERN_WARNING "Unknown node type for REF_PRISTINE node at 0x%08x: 0x%04x\n", 6471da177e4SLinus Torvalds ref_offset(raw), je16_to_cpu(node->u.nodetype)); 6481da177e4SLinus Torvalds goto bail; 6491da177e4SLinus Torvalds } 6506171586aSDavid Woodhouse } 6511da177e4SLinus Torvalds 6521da177e4SLinus Torvalds /* OK, all the CRCs are good; this node can just be copied as-is. */ 6531da177e4SLinus Torvalds retry: 6542f785402SDavid Woodhouse phys_ofs = write_ofs(c); 6551da177e4SLinus Torvalds 6561da177e4SLinus Torvalds ret = jffs2_flash_write(c, phys_ofs, rawlen, &retlen, (char *)node); 6571da177e4SLinus Torvalds 6581da177e4SLinus Torvalds if (ret || (retlen != rawlen)) { 6591da177e4SLinus Torvalds printk(KERN_NOTICE "Write of %d bytes at 0x%08x failed. returned %d, retlen %zd\n", 6602f785402SDavid Woodhouse rawlen, phys_ofs, ret, retlen); 6611da177e4SLinus Torvalds if (retlen) { 6622f785402SDavid Woodhouse jffs2_add_physical_node_ref(c, phys_ofs | REF_OBSOLETE, rawlen, NULL); 6631da177e4SLinus Torvalds } else { 6642f785402SDavid Woodhouse printk(KERN_NOTICE "Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", phys_ofs); 6651da177e4SLinus Torvalds } 6662f785402SDavid Woodhouse if (!retried) { 6671da177e4SLinus Torvalds /* Try to reallocate space and retry */ 6681da177e4SLinus Torvalds uint32_t dummy; 6691da177e4SLinus Torvalds struct jffs2_eraseblock *jeb = &c->blocks[phys_ofs / c->sector_size]; 6701da177e4SLinus Torvalds 6711da177e4SLinus Torvalds retried = 1; 6721da177e4SLinus Torvalds 6731da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Retrying failed write of REF_PRISTINE node.\n")); 6741da177e4SLinus Torvalds 675730554d9SArtem B. Bityutskiy jffs2_dbg_acct_sanity_check(c,jeb); 676730554d9SArtem B. Bityutskiy jffs2_dbg_acct_paranoia_check(c, jeb); 6771da177e4SLinus Torvalds 6789fe4854cSDavid Woodhouse ret = jffs2_reserve_space_gc(c, rawlen, &dummy, rawlen); 679e631ddbaSFerenc Havasi /* this is not the exact summary size of it, 680e631ddbaSFerenc Havasi it is only an upper estimation */ 6811da177e4SLinus Torvalds 6821da177e4SLinus Torvalds if (!ret) { 6831da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Allocated space at 0x%08x to retry failed write.\n", phys_ofs)); 6841da177e4SLinus Torvalds 685730554d9SArtem B. Bityutskiy jffs2_dbg_acct_sanity_check(c,jeb); 686730554d9SArtem B. Bityutskiy jffs2_dbg_acct_paranoia_check(c, jeb); 6871da177e4SLinus Torvalds 6881da177e4SLinus Torvalds goto retry; 6891da177e4SLinus Torvalds } 6901da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Failed to allocate space to retry failed write: %d!\n", ret)); 6911da177e4SLinus Torvalds } 6921da177e4SLinus Torvalds 6931da177e4SLinus Torvalds if (!ret) 6941da177e4SLinus Torvalds ret = -EIO; 6951da177e4SLinus Torvalds goto out_node; 6961da177e4SLinus Torvalds } 6972f785402SDavid Woodhouse jffs2_add_physical_node_ref(c, phys_ofs | REF_PRISTINE, rawlen, ic); 6981da177e4SLinus Torvalds 6991da177e4SLinus Torvalds jffs2_mark_node_obsolete(c, raw); 7001da177e4SLinus Torvalds D1(printk(KERN_DEBUG "WHEEE! GC REF_PRISTINE node at 0x%08x succeeded\n", ref_offset(raw))); 7011da177e4SLinus Torvalds 7021da177e4SLinus Torvalds out_node: 7031da177e4SLinus Torvalds kfree(node); 7041da177e4SLinus Torvalds return ret; 7051da177e4SLinus Torvalds bail: 7061da177e4SLinus Torvalds ret = -EBADFD; 7071da177e4SLinus Torvalds goto out_node; 7081da177e4SLinus Torvalds } 7091da177e4SLinus Torvalds 7101da177e4SLinus Torvalds static int jffs2_garbage_collect_metadata(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 7111da177e4SLinus Torvalds struct jffs2_inode_info *f, struct jffs2_full_dnode *fn) 7121da177e4SLinus Torvalds { 7131da177e4SLinus Torvalds struct jffs2_full_dnode *new_fn; 7141da177e4SLinus Torvalds struct jffs2_raw_inode ri; 7158557fd51SArtem B. Bityuckiy struct jffs2_node_frag *last_frag; 716aef9ab47SDavid Woodhouse union jffs2_device_node dev; 7172e16cfcaSDavid Woodhouse char *mdata = NULL; 7182e16cfcaSDavid Woodhouse int mdatalen = 0; 7199fe4854cSDavid Woodhouse uint32_t alloclen, ilen; 7201da177e4SLinus Torvalds int ret; 7211da177e4SLinus Torvalds 7221da177e4SLinus Torvalds if (S_ISBLK(JFFS2_F_I_MODE(f)) || 7231da177e4SLinus Torvalds S_ISCHR(JFFS2_F_I_MODE(f)) ) { 7241da177e4SLinus Torvalds /* For these, we don't actually need to read the old node */ 725aef9ab47SDavid Woodhouse mdatalen = jffs2_encode_dev(&dev, JFFS2_F_I_RDEV(f)); 7261da177e4SLinus Torvalds mdata = (char *)&dev; 7271da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_garbage_collect_metadata(): Writing %d bytes of kdev_t\n", mdatalen)); 7281da177e4SLinus Torvalds } else if (S_ISLNK(JFFS2_F_I_MODE(f))) { 7291da177e4SLinus Torvalds mdatalen = fn->size; 7301da177e4SLinus Torvalds mdata = kmalloc(fn->size, GFP_KERNEL); 7311da177e4SLinus Torvalds if (!mdata) { 7321da177e4SLinus Torvalds printk(KERN_WARNING "kmalloc of mdata failed in jffs2_garbage_collect_metadata()\n"); 7331da177e4SLinus Torvalds return -ENOMEM; 7341da177e4SLinus Torvalds } 7351da177e4SLinus Torvalds ret = jffs2_read_dnode(c, f, fn, mdata, 0, mdatalen); 7361da177e4SLinus Torvalds if (ret) { 7371da177e4SLinus Torvalds printk(KERN_WARNING "read of old metadata failed in jffs2_garbage_collect_metadata(): %d\n", ret); 7381da177e4SLinus Torvalds kfree(mdata); 7391da177e4SLinus Torvalds return ret; 7401da177e4SLinus Torvalds } 7411da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_garbage_collect_metadata(): Writing %d bites of symlink target\n", mdatalen)); 7421da177e4SLinus Torvalds 7431da177e4SLinus Torvalds } 7441da177e4SLinus Torvalds 7459fe4854cSDavid Woodhouse ret = jffs2_reserve_space_gc(c, sizeof(ri) + mdatalen, &alloclen, 746e631ddbaSFerenc Havasi JFFS2_SUMMARY_INODE_SIZE); 7471da177e4SLinus Torvalds if (ret) { 7481da177e4SLinus Torvalds printk(KERN_WARNING "jffs2_reserve_space_gc of %zd bytes for garbage_collect_metadata failed: %d\n", 7491da177e4SLinus Torvalds sizeof(ri)+ mdatalen, ret); 7501da177e4SLinus Torvalds goto out; 7511da177e4SLinus Torvalds } 7521da177e4SLinus Torvalds 7538557fd51SArtem B. Bityuckiy last_frag = frag_last(&f->fragtree); 7548557fd51SArtem B. Bityuckiy if (last_frag) 7558557fd51SArtem B. Bityuckiy /* Fetch the inode length from the fragtree rather then 7568557fd51SArtem B. Bityuckiy * from i_size since i_size may have not been updated yet */ 7578557fd51SArtem B. Bityuckiy ilen = last_frag->ofs + last_frag->size; 7588557fd51SArtem B. Bityuckiy else 7598557fd51SArtem B. Bityuckiy ilen = JFFS2_F_I_SIZE(f); 7608557fd51SArtem B. Bityuckiy 7611da177e4SLinus Torvalds memset(&ri, 0, sizeof(ri)); 7621da177e4SLinus Torvalds ri.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 7631da177e4SLinus Torvalds ri.nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE); 7641da177e4SLinus Torvalds ri.totlen = cpu_to_je32(sizeof(ri) + mdatalen); 7651da177e4SLinus Torvalds ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4)); 7661da177e4SLinus Torvalds 7671da177e4SLinus Torvalds ri.ino = cpu_to_je32(f->inocache->ino); 7681da177e4SLinus Torvalds ri.version = cpu_to_je32(++f->highest_version); 7691da177e4SLinus Torvalds ri.mode = cpu_to_jemode(JFFS2_F_I_MODE(f)); 7701da177e4SLinus Torvalds ri.uid = cpu_to_je16(JFFS2_F_I_UID(f)); 7711da177e4SLinus Torvalds ri.gid = cpu_to_je16(JFFS2_F_I_GID(f)); 7728557fd51SArtem B. Bityuckiy ri.isize = cpu_to_je32(ilen); 7731da177e4SLinus Torvalds ri.atime = cpu_to_je32(JFFS2_F_I_ATIME(f)); 7741da177e4SLinus Torvalds ri.ctime = cpu_to_je32(JFFS2_F_I_CTIME(f)); 7751da177e4SLinus Torvalds ri.mtime = cpu_to_je32(JFFS2_F_I_MTIME(f)); 7761da177e4SLinus Torvalds ri.offset = cpu_to_je32(0); 7771da177e4SLinus Torvalds ri.csize = cpu_to_je32(mdatalen); 7781da177e4SLinus Torvalds ri.dsize = cpu_to_je32(mdatalen); 7791da177e4SLinus Torvalds ri.compr = JFFS2_COMPR_NONE; 7801da177e4SLinus Torvalds ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8)); 7811da177e4SLinus Torvalds ri.data_crc = cpu_to_je32(crc32(0, mdata, mdatalen)); 7821da177e4SLinus Torvalds 7839fe4854cSDavid Woodhouse new_fn = jffs2_write_dnode(c, f, &ri, mdata, mdatalen, ALLOC_GC); 7841da177e4SLinus Torvalds 7851da177e4SLinus Torvalds if (IS_ERR(new_fn)) { 7861da177e4SLinus Torvalds printk(KERN_WARNING "Error writing new dnode: %ld\n", PTR_ERR(new_fn)); 7871da177e4SLinus Torvalds ret = PTR_ERR(new_fn); 7881da177e4SLinus Torvalds goto out; 7891da177e4SLinus Torvalds } 7901da177e4SLinus Torvalds jffs2_mark_node_obsolete(c, fn->raw); 7911da177e4SLinus Torvalds jffs2_free_full_dnode(fn); 7921da177e4SLinus Torvalds f->metadata = new_fn; 7931da177e4SLinus Torvalds out: 7941da177e4SLinus Torvalds if (S_ISLNK(JFFS2_F_I_MODE(f))) 7951da177e4SLinus Torvalds kfree(mdata); 7961da177e4SLinus Torvalds return ret; 7971da177e4SLinus Torvalds } 7981da177e4SLinus Torvalds 7991da177e4SLinus Torvalds static int jffs2_garbage_collect_dirent(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 8001da177e4SLinus Torvalds struct jffs2_inode_info *f, struct jffs2_full_dirent *fd) 8011da177e4SLinus Torvalds { 8021da177e4SLinus Torvalds struct jffs2_full_dirent *new_fd; 8031da177e4SLinus Torvalds struct jffs2_raw_dirent rd; 8049fe4854cSDavid Woodhouse uint32_t alloclen; 8051da177e4SLinus Torvalds int ret; 8061da177e4SLinus Torvalds 8071da177e4SLinus Torvalds rd.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 8081da177e4SLinus Torvalds rd.nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT); 8091da177e4SLinus Torvalds rd.nsize = strlen(fd->name); 8101da177e4SLinus Torvalds rd.totlen = cpu_to_je32(sizeof(rd) + rd.nsize); 8111da177e4SLinus Torvalds rd.hdr_crc = cpu_to_je32(crc32(0, &rd, sizeof(struct jffs2_unknown_node)-4)); 8121da177e4SLinus Torvalds 8131da177e4SLinus Torvalds rd.pino = cpu_to_je32(f->inocache->ino); 8141da177e4SLinus Torvalds rd.version = cpu_to_je32(++f->highest_version); 8151da177e4SLinus Torvalds rd.ino = cpu_to_je32(fd->ino); 8163a69e0cdSArtem B. Bityutskiy /* If the times on this inode were set by explicit utime() they can be different, 8173a69e0cdSArtem B. Bityutskiy so refrain from splatting them. */ 8183a69e0cdSArtem B. Bityutskiy if (JFFS2_F_I_MTIME(f) == JFFS2_F_I_CTIME(f)) 8193a69e0cdSArtem B. Bityutskiy rd.mctime = cpu_to_je32(JFFS2_F_I_MTIME(f)); 8203a69e0cdSArtem B. Bityutskiy else 8213a69e0cdSArtem B. Bityutskiy rd.mctime = cpu_to_je32(0); 8221da177e4SLinus Torvalds rd.type = fd->type; 8231da177e4SLinus Torvalds rd.node_crc = cpu_to_je32(crc32(0, &rd, sizeof(rd)-8)); 8241da177e4SLinus Torvalds rd.name_crc = cpu_to_je32(crc32(0, fd->name, rd.nsize)); 8251da177e4SLinus Torvalds 8269fe4854cSDavid Woodhouse ret = jffs2_reserve_space_gc(c, sizeof(rd)+rd.nsize, &alloclen, 827e631ddbaSFerenc Havasi JFFS2_SUMMARY_DIRENT_SIZE(rd.nsize)); 8281da177e4SLinus Torvalds if (ret) { 8291da177e4SLinus Torvalds printk(KERN_WARNING "jffs2_reserve_space_gc of %zd bytes for garbage_collect_dirent failed: %d\n", 8301da177e4SLinus Torvalds sizeof(rd)+rd.nsize, ret); 8311da177e4SLinus Torvalds return ret; 8321da177e4SLinus Torvalds } 8339fe4854cSDavid Woodhouse new_fd = jffs2_write_dirent(c, f, &rd, fd->name, rd.nsize, ALLOC_GC); 8341da177e4SLinus Torvalds 8351da177e4SLinus Torvalds if (IS_ERR(new_fd)) { 8361da177e4SLinus Torvalds printk(KERN_WARNING "jffs2_write_dirent in garbage_collect_dirent failed: %ld\n", PTR_ERR(new_fd)); 8371da177e4SLinus Torvalds return PTR_ERR(new_fd); 8381da177e4SLinus Torvalds } 8391da177e4SLinus Torvalds jffs2_add_fd_to_list(c, new_fd, &f->dents); 8401da177e4SLinus Torvalds return 0; 8411da177e4SLinus Torvalds } 8421da177e4SLinus Torvalds 8431da177e4SLinus Torvalds static int jffs2_garbage_collect_deletion_dirent(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 8441da177e4SLinus Torvalds struct jffs2_inode_info *f, struct jffs2_full_dirent *fd) 8451da177e4SLinus Torvalds { 8461da177e4SLinus Torvalds struct jffs2_full_dirent **fdp = &f->dents; 8471da177e4SLinus Torvalds int found = 0; 8481da177e4SLinus Torvalds 8491da177e4SLinus Torvalds /* On a medium where we can't actually mark nodes obsolete 8501da177e4SLinus Torvalds pernamently, such as NAND flash, we need to work out 8511da177e4SLinus Torvalds whether this deletion dirent is still needed to actively 8521da177e4SLinus Torvalds delete a 'real' dirent with the same name that's still 8531da177e4SLinus Torvalds somewhere else on the flash. */ 8541da177e4SLinus Torvalds if (!jffs2_can_mark_obsolete(c)) { 8551da177e4SLinus Torvalds struct jffs2_raw_dirent *rd; 8561da177e4SLinus Torvalds struct jffs2_raw_node_ref *raw; 8571da177e4SLinus Torvalds int ret; 8581da177e4SLinus Torvalds size_t retlen; 8591da177e4SLinus Torvalds int name_len = strlen(fd->name); 8601da177e4SLinus Torvalds uint32_t name_crc = crc32(0, fd->name, name_len); 8611da177e4SLinus Torvalds uint32_t rawlen = ref_totlen(c, jeb, fd->raw); 8621da177e4SLinus Torvalds 8631da177e4SLinus Torvalds rd = kmalloc(rawlen, GFP_KERNEL); 8641da177e4SLinus Torvalds if (!rd) 8651da177e4SLinus Torvalds return -ENOMEM; 8661da177e4SLinus Torvalds 8671da177e4SLinus Torvalds /* Prevent the erase code from nicking the obsolete node refs while 8681da177e4SLinus Torvalds we're looking at them. I really don't like this extra lock but 8691da177e4SLinus Torvalds can't see any alternative. Suggestions on a postcard to... */ 870ced22070SDavid Woodhouse mutex_lock(&c->erase_free_sem); 8711da177e4SLinus Torvalds 8721da177e4SLinus Torvalds for (raw = f->inocache->nodes; raw != (void *)f->inocache; raw = raw->next_in_ino) { 8731da177e4SLinus Torvalds 874aba54da3SArtem Bityutskiy cond_resched(); 875aba54da3SArtem Bityutskiy 8761da177e4SLinus Torvalds /* We only care about obsolete ones */ 8771da177e4SLinus Torvalds if (!(ref_obsolete(raw))) 8781da177e4SLinus Torvalds continue; 8791da177e4SLinus Torvalds 8801da177e4SLinus Torvalds /* Any dirent with the same name is going to have the same length... */ 8811da177e4SLinus Torvalds if (ref_totlen(c, NULL, raw) != rawlen) 8821da177e4SLinus Torvalds continue; 8831da177e4SLinus Torvalds 8841da177e4SLinus Torvalds /* Doesn't matter if there's one in the same erase block. We're going to 8851da177e4SLinus Torvalds delete it too at the same time. */ 8863be36675SAndrew Victor if (SECTOR_ADDR(raw->flash_offset) == SECTOR_ADDR(fd->raw->flash_offset)) 8871da177e4SLinus Torvalds continue; 8881da177e4SLinus Torvalds 8891da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Check potential deletion dirent at %08x\n", ref_offset(raw))); 8901da177e4SLinus Torvalds 8911da177e4SLinus Torvalds /* This is an obsolete node belonging to the same directory, and it's of the right 8921da177e4SLinus Torvalds length. We need to take a closer look...*/ 8931da177e4SLinus Torvalds ret = jffs2_flash_read(c, ref_offset(raw), rawlen, &retlen, (char *)rd); 8941da177e4SLinus Torvalds if (ret) { 8951da177e4SLinus Torvalds printk(KERN_WARNING "jffs2_g_c_deletion_dirent(): Read error (%d) reading obsolete node at %08x\n", ret, ref_offset(raw)); 8961da177e4SLinus Torvalds /* If we can't read it, we don't need to continue to obsolete it. Continue */ 8971da177e4SLinus Torvalds continue; 8981da177e4SLinus Torvalds } 8991da177e4SLinus Torvalds if (retlen != rawlen) { 9001da177e4SLinus Torvalds printk(KERN_WARNING "jffs2_g_c_deletion_dirent(): Short read (%zd not %u) reading header from obsolete node at %08x\n", 9011da177e4SLinus Torvalds retlen, rawlen, ref_offset(raw)); 9021da177e4SLinus Torvalds continue; 9031da177e4SLinus Torvalds } 9041da177e4SLinus Torvalds 9051da177e4SLinus Torvalds if (je16_to_cpu(rd->nodetype) != JFFS2_NODETYPE_DIRENT) 9061da177e4SLinus Torvalds continue; 9071da177e4SLinus Torvalds 9081da177e4SLinus Torvalds /* If the name CRC doesn't match, skip */ 9091da177e4SLinus Torvalds if (je32_to_cpu(rd->name_crc) != name_crc) 9101da177e4SLinus Torvalds continue; 9111da177e4SLinus Torvalds 9121da177e4SLinus Torvalds /* If the name length doesn't match, or it's another deletion dirent, skip */ 9131da177e4SLinus Torvalds if (rd->nsize != name_len || !je32_to_cpu(rd->ino)) 9141da177e4SLinus Torvalds continue; 9151da177e4SLinus Torvalds 9161da177e4SLinus Torvalds /* OK, check the actual name now */ 9171da177e4SLinus Torvalds if (memcmp(rd->name, fd->name, name_len)) 9181da177e4SLinus Torvalds continue; 9191da177e4SLinus Torvalds 9201da177e4SLinus Torvalds /* OK. The name really does match. There really is still an older node on 9211da177e4SLinus Torvalds the flash which our deletion dirent obsoletes. So we have to write out 9221da177e4SLinus Torvalds a new deletion dirent to replace it */ 923ced22070SDavid Woodhouse mutex_unlock(&c->erase_free_sem); 9241da177e4SLinus Torvalds 9251da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Deletion dirent at %08x still obsoletes real dirent \"%s\" at %08x for ino #%u\n", 9261da177e4SLinus Torvalds ref_offset(fd->raw), fd->name, ref_offset(raw), je32_to_cpu(rd->ino))); 9271da177e4SLinus Torvalds kfree(rd); 9281da177e4SLinus Torvalds 9291da177e4SLinus Torvalds return jffs2_garbage_collect_dirent(c, jeb, f, fd); 9301da177e4SLinus Torvalds } 9311da177e4SLinus Torvalds 932ced22070SDavid Woodhouse mutex_unlock(&c->erase_free_sem); 9331da177e4SLinus Torvalds kfree(rd); 9341da177e4SLinus Torvalds } 9351da177e4SLinus Torvalds 9363a69e0cdSArtem B. Bityutskiy /* FIXME: If we're deleting a dirent which contains the current mtime and ctime, 9373a69e0cdSArtem B. Bityutskiy we should update the metadata node with those times accordingly */ 9383a69e0cdSArtem B. Bityutskiy 9391da177e4SLinus Torvalds /* No need for it any more. Just mark it obsolete and remove it from the list */ 9401da177e4SLinus Torvalds while (*fdp) { 9411da177e4SLinus Torvalds if ((*fdp) == fd) { 9421da177e4SLinus Torvalds found = 1; 9431da177e4SLinus Torvalds *fdp = fd->next; 9441da177e4SLinus Torvalds break; 9451da177e4SLinus Torvalds } 9461da177e4SLinus Torvalds fdp = &(*fdp)->next; 9471da177e4SLinus Torvalds } 9481da177e4SLinus Torvalds if (!found) { 9491da177e4SLinus Torvalds printk(KERN_WARNING "Deletion dirent \"%s\" not found in list for ino #%u\n", fd->name, f->inocache->ino); 9501da177e4SLinus Torvalds } 9511da177e4SLinus Torvalds jffs2_mark_node_obsolete(c, fd->raw); 9521da177e4SLinus Torvalds jffs2_free_full_dirent(fd); 9531da177e4SLinus Torvalds return 0; 9541da177e4SLinus Torvalds } 9551da177e4SLinus Torvalds 9561da177e4SLinus Torvalds static int jffs2_garbage_collect_hole(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 9571da177e4SLinus Torvalds struct jffs2_inode_info *f, struct jffs2_full_dnode *fn, 9581da177e4SLinus Torvalds uint32_t start, uint32_t end) 9591da177e4SLinus Torvalds { 9601da177e4SLinus Torvalds struct jffs2_raw_inode ri; 9611da177e4SLinus Torvalds struct jffs2_node_frag *frag; 9621da177e4SLinus Torvalds struct jffs2_full_dnode *new_fn; 9639fe4854cSDavid Woodhouse uint32_t alloclen, ilen; 9641da177e4SLinus Torvalds int ret; 9651da177e4SLinus Torvalds 9661da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Writing replacement hole node for ino #%u from offset 0x%x to 0x%x\n", 9671da177e4SLinus Torvalds f->inocache->ino, start, end)); 9681da177e4SLinus Torvalds 9691da177e4SLinus Torvalds memset(&ri, 0, sizeof(ri)); 9701da177e4SLinus Torvalds 9711da177e4SLinus Torvalds if(fn->frags > 1) { 9721da177e4SLinus Torvalds size_t readlen; 9731da177e4SLinus Torvalds uint32_t crc; 9741da177e4SLinus Torvalds /* It's partially obsoleted by a later write. So we have to 9751da177e4SLinus Torvalds write it out again with the _same_ version as before */ 9761da177e4SLinus Torvalds ret = jffs2_flash_read(c, ref_offset(fn->raw), sizeof(ri), &readlen, (char *)&ri); 9771da177e4SLinus Torvalds if (readlen != sizeof(ri) || ret) { 9781da177e4SLinus Torvalds printk(KERN_WARNING "Node read failed in jffs2_garbage_collect_hole. Ret %d, retlen %zd. Data will be lost by writing new hole node\n", ret, readlen); 9791da177e4SLinus Torvalds goto fill; 9801da177e4SLinus Torvalds } 9811da177e4SLinus Torvalds if (je16_to_cpu(ri.nodetype) != JFFS2_NODETYPE_INODE) { 9821da177e4SLinus Torvalds printk(KERN_WARNING "jffs2_garbage_collect_hole: Node at 0x%08x had node type 0x%04x instead of JFFS2_NODETYPE_INODE(0x%04x)\n", 9831da177e4SLinus Torvalds ref_offset(fn->raw), 9841da177e4SLinus Torvalds je16_to_cpu(ri.nodetype), JFFS2_NODETYPE_INODE); 9851da177e4SLinus Torvalds return -EIO; 9861da177e4SLinus Torvalds } 9871da177e4SLinus Torvalds if (je32_to_cpu(ri.totlen) != sizeof(ri)) { 9881da177e4SLinus Torvalds printk(KERN_WARNING "jffs2_garbage_collect_hole: Node at 0x%08x had totlen 0x%x instead of expected 0x%zx\n", 9891da177e4SLinus Torvalds ref_offset(fn->raw), 9901da177e4SLinus Torvalds je32_to_cpu(ri.totlen), sizeof(ri)); 9911da177e4SLinus Torvalds return -EIO; 9921da177e4SLinus Torvalds } 9931da177e4SLinus Torvalds crc = crc32(0, &ri, sizeof(ri)-8); 9941da177e4SLinus Torvalds if (crc != je32_to_cpu(ri.node_crc)) { 9951da177e4SLinus Torvalds printk(KERN_WARNING "jffs2_garbage_collect_hole: Node at 0x%08x had CRC 0x%08x which doesn't match calculated CRC 0x%08x\n", 9961da177e4SLinus Torvalds ref_offset(fn->raw), 9971da177e4SLinus Torvalds je32_to_cpu(ri.node_crc), crc); 9981da177e4SLinus Torvalds /* FIXME: We could possibly deal with this by writing new holes for each frag */ 9991da177e4SLinus Torvalds printk(KERN_WARNING "Data in the range 0x%08x to 0x%08x of inode #%u will be lost\n", 10001da177e4SLinus Torvalds start, end, f->inocache->ino); 10011da177e4SLinus Torvalds goto fill; 10021da177e4SLinus Torvalds } 10031da177e4SLinus Torvalds if (ri.compr != JFFS2_COMPR_ZERO) { 10041da177e4SLinus Torvalds printk(KERN_WARNING "jffs2_garbage_collect_hole: Node 0x%08x wasn't a hole node!\n", ref_offset(fn->raw)); 10051da177e4SLinus Torvalds printk(KERN_WARNING "Data in the range 0x%08x to 0x%08x of inode #%u will be lost\n", 10061da177e4SLinus Torvalds start, end, f->inocache->ino); 10071da177e4SLinus Torvalds goto fill; 10081da177e4SLinus Torvalds } 10091da177e4SLinus Torvalds } else { 10101da177e4SLinus Torvalds fill: 10111da177e4SLinus Torvalds ri.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 10121da177e4SLinus Torvalds ri.nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE); 10131da177e4SLinus Torvalds ri.totlen = cpu_to_je32(sizeof(ri)); 10141da177e4SLinus Torvalds ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4)); 10151da177e4SLinus Torvalds 10161da177e4SLinus Torvalds ri.ino = cpu_to_je32(f->inocache->ino); 10171da177e4SLinus Torvalds ri.version = cpu_to_je32(++f->highest_version); 10181da177e4SLinus Torvalds ri.offset = cpu_to_je32(start); 10191da177e4SLinus Torvalds ri.dsize = cpu_to_je32(end - start); 10201da177e4SLinus Torvalds ri.csize = cpu_to_je32(0); 10211da177e4SLinus Torvalds ri.compr = JFFS2_COMPR_ZERO; 10221da177e4SLinus Torvalds } 10238557fd51SArtem B. Bityuckiy 10248557fd51SArtem B. Bityuckiy frag = frag_last(&f->fragtree); 10258557fd51SArtem B. Bityuckiy if (frag) 10268557fd51SArtem B. Bityuckiy /* Fetch the inode length from the fragtree rather then 10278557fd51SArtem B. Bityuckiy * from i_size since i_size may have not been updated yet */ 10288557fd51SArtem B. Bityuckiy ilen = frag->ofs + frag->size; 10298557fd51SArtem B. Bityuckiy else 10308557fd51SArtem B. Bityuckiy ilen = JFFS2_F_I_SIZE(f); 10318557fd51SArtem B. Bityuckiy 10321da177e4SLinus Torvalds ri.mode = cpu_to_jemode(JFFS2_F_I_MODE(f)); 10331da177e4SLinus Torvalds ri.uid = cpu_to_je16(JFFS2_F_I_UID(f)); 10341da177e4SLinus Torvalds ri.gid = cpu_to_je16(JFFS2_F_I_GID(f)); 10358557fd51SArtem B. Bityuckiy ri.isize = cpu_to_je32(ilen); 10361da177e4SLinus Torvalds ri.atime = cpu_to_je32(JFFS2_F_I_ATIME(f)); 10371da177e4SLinus Torvalds ri.ctime = cpu_to_je32(JFFS2_F_I_CTIME(f)); 10381da177e4SLinus Torvalds ri.mtime = cpu_to_je32(JFFS2_F_I_MTIME(f)); 10391da177e4SLinus Torvalds ri.data_crc = cpu_to_je32(0); 10401da177e4SLinus Torvalds ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8)); 10411da177e4SLinus Torvalds 10429fe4854cSDavid Woodhouse ret = jffs2_reserve_space_gc(c, sizeof(ri), &alloclen, 1043e631ddbaSFerenc Havasi JFFS2_SUMMARY_INODE_SIZE); 10441da177e4SLinus Torvalds if (ret) { 10451da177e4SLinus Torvalds printk(KERN_WARNING "jffs2_reserve_space_gc of %zd bytes for garbage_collect_hole failed: %d\n", 10461da177e4SLinus Torvalds sizeof(ri), ret); 10471da177e4SLinus Torvalds return ret; 10481da177e4SLinus Torvalds } 10499fe4854cSDavid Woodhouse new_fn = jffs2_write_dnode(c, f, &ri, NULL, 0, ALLOC_GC); 10501da177e4SLinus Torvalds 10511da177e4SLinus Torvalds if (IS_ERR(new_fn)) { 10521da177e4SLinus Torvalds printk(KERN_WARNING "Error writing new hole node: %ld\n", PTR_ERR(new_fn)); 10531da177e4SLinus Torvalds return PTR_ERR(new_fn); 10541da177e4SLinus Torvalds } 10551da177e4SLinus Torvalds if (je32_to_cpu(ri.version) == f->highest_version) { 10561da177e4SLinus Torvalds jffs2_add_full_dnode_to_inode(c, f, new_fn); 10571da177e4SLinus Torvalds if (f->metadata) { 10581da177e4SLinus Torvalds jffs2_mark_node_obsolete(c, f->metadata->raw); 10591da177e4SLinus Torvalds jffs2_free_full_dnode(f->metadata); 10601da177e4SLinus Torvalds f->metadata = NULL; 10611da177e4SLinus Torvalds } 10621da177e4SLinus Torvalds return 0; 10631da177e4SLinus Torvalds } 10641da177e4SLinus Torvalds 10651da177e4SLinus Torvalds /* 10661da177e4SLinus Torvalds * We should only get here in the case where the node we are 10671da177e4SLinus Torvalds * replacing had more than one frag, so we kept the same version 10681da177e4SLinus Torvalds * number as before. (Except in case of error -- see 'goto fill;' 10691da177e4SLinus Torvalds * above.) 10701da177e4SLinus Torvalds */ 10711da177e4SLinus Torvalds D1(if(unlikely(fn->frags <= 1)) { 10721da177e4SLinus Torvalds printk(KERN_WARNING "jffs2_garbage_collect_hole: Replacing fn with %d frag(s) but new ver %d != highest_version %d of ino #%d\n", 10731da177e4SLinus Torvalds fn->frags, je32_to_cpu(ri.version), f->highest_version, 10741da177e4SLinus Torvalds je32_to_cpu(ri.ino)); 10751da177e4SLinus Torvalds }); 10761da177e4SLinus Torvalds 10771da177e4SLinus Torvalds /* This is a partially-overlapped hole node. Mark it REF_NORMAL not REF_PRISTINE */ 10781da177e4SLinus Torvalds mark_ref_normal(new_fn->raw); 10791da177e4SLinus Torvalds 10801da177e4SLinus Torvalds for (frag = jffs2_lookup_node_frag(&f->fragtree, fn->ofs); 10811da177e4SLinus Torvalds frag; frag = frag_next(frag)) { 10821da177e4SLinus Torvalds if (frag->ofs > fn->size + fn->ofs) 10831da177e4SLinus Torvalds break; 10841da177e4SLinus Torvalds if (frag->node == fn) { 10851da177e4SLinus Torvalds frag->node = new_fn; 10861da177e4SLinus Torvalds new_fn->frags++; 10871da177e4SLinus Torvalds fn->frags--; 10881da177e4SLinus Torvalds } 10891da177e4SLinus Torvalds } 10901da177e4SLinus Torvalds if (fn->frags) { 10911da177e4SLinus Torvalds printk(KERN_WARNING "jffs2_garbage_collect_hole: Old node still has frags!\n"); 10921da177e4SLinus Torvalds BUG(); 10931da177e4SLinus Torvalds } 10941da177e4SLinus Torvalds if (!new_fn->frags) { 10951da177e4SLinus Torvalds printk(KERN_WARNING "jffs2_garbage_collect_hole: New node has no frags!\n"); 10961da177e4SLinus Torvalds BUG(); 10971da177e4SLinus Torvalds } 10981da177e4SLinus Torvalds 10991da177e4SLinus Torvalds jffs2_mark_node_obsolete(c, fn->raw); 11001da177e4SLinus Torvalds jffs2_free_full_dnode(fn); 11011da177e4SLinus Torvalds 11021da177e4SLinus Torvalds return 0; 11031da177e4SLinus Torvalds } 11041da177e4SLinus Torvalds 110525dc30b4SDavid Woodhouse static int jffs2_garbage_collect_dnode(struct jffs2_sb_info *c, struct jffs2_eraseblock *orig_jeb, 11061da177e4SLinus Torvalds struct jffs2_inode_info *f, struct jffs2_full_dnode *fn, 11071da177e4SLinus Torvalds uint32_t start, uint32_t end) 11081da177e4SLinus Torvalds { 11091da177e4SLinus Torvalds struct jffs2_full_dnode *new_fn; 11101da177e4SLinus Torvalds struct jffs2_raw_inode ri; 11119fe4854cSDavid Woodhouse uint32_t alloclen, offset, orig_end, orig_start; 11121da177e4SLinus Torvalds int ret = 0; 11131da177e4SLinus Torvalds unsigned char *comprbuf = NULL, *writebuf; 11141da177e4SLinus Torvalds unsigned long pg; 11151da177e4SLinus Torvalds unsigned char *pg_ptr; 11161da177e4SLinus Torvalds 11171da177e4SLinus Torvalds memset(&ri, 0, sizeof(ri)); 11181da177e4SLinus Torvalds 11191da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Writing replacement dnode for ino #%u from offset 0x%x to 0x%x\n", 11201da177e4SLinus Torvalds f->inocache->ino, start, end)); 11211da177e4SLinus Torvalds 11221da177e4SLinus Torvalds orig_end = end; 11231da177e4SLinus Torvalds orig_start = start; 11241da177e4SLinus Torvalds 11251da177e4SLinus Torvalds if (c->nr_free_blocks + c->nr_erasing_blocks > c->resv_blocks_gcmerge) { 11261da177e4SLinus Torvalds /* Attempt to do some merging. But only expand to cover logically 11271da177e4SLinus Torvalds adjacent frags if the block containing them is already considered 11281da177e4SLinus Torvalds to be dirty. Otherwise we end up with GC just going round in 11291da177e4SLinus Torvalds circles dirtying the nodes it already wrote out, especially 11301da177e4SLinus Torvalds on NAND where we have small eraseblocks and hence a much higher 11311da177e4SLinus Torvalds chance of nodes having to be split to cross boundaries. */ 11321da177e4SLinus Torvalds 11331da177e4SLinus Torvalds struct jffs2_node_frag *frag; 11341da177e4SLinus Torvalds uint32_t min, max; 11351da177e4SLinus Torvalds 11361da177e4SLinus Torvalds min = start & ~(PAGE_CACHE_SIZE-1); 11371da177e4SLinus Torvalds max = min + PAGE_CACHE_SIZE; 11381da177e4SLinus Torvalds 11391da177e4SLinus Torvalds frag = jffs2_lookup_node_frag(&f->fragtree, start); 11401da177e4SLinus Torvalds 11411da177e4SLinus Torvalds /* BUG_ON(!frag) but that'll happen anyway... */ 11421da177e4SLinus Torvalds 11431da177e4SLinus Torvalds BUG_ON(frag->ofs != start); 11441da177e4SLinus Torvalds 11451da177e4SLinus Torvalds /* First grow down... */ 11461da177e4SLinus Torvalds while((frag = frag_prev(frag)) && frag->ofs >= min) { 11471da177e4SLinus Torvalds 11481da177e4SLinus Torvalds /* If the previous frag doesn't even reach the beginning, there's 11491da177e4SLinus Torvalds excessive fragmentation. Just merge. */ 11501da177e4SLinus Torvalds if (frag->ofs > min) { 11511da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Expanding down to cover partial frag (0x%x-0x%x)\n", 11521da177e4SLinus Torvalds frag->ofs, frag->ofs+frag->size)); 11531da177e4SLinus Torvalds start = frag->ofs; 11541da177e4SLinus Torvalds continue; 11551da177e4SLinus Torvalds } 11561da177e4SLinus Torvalds /* OK. This frag holds the first byte of the page. */ 11571da177e4SLinus Torvalds if (!frag->node || !frag->node->raw) { 11581da177e4SLinus Torvalds D1(printk(KERN_DEBUG "First frag in page is hole (0x%x-0x%x). Not expanding down.\n", 11591da177e4SLinus Torvalds frag->ofs, frag->ofs+frag->size)); 11601da177e4SLinus Torvalds break; 11611da177e4SLinus Torvalds } else { 11621da177e4SLinus Torvalds 11631da177e4SLinus Torvalds /* OK, it's a frag which extends to the beginning of the page. Does it live 11641da177e4SLinus Torvalds in a block which is still considered clean? If so, don't obsolete it. 11651da177e4SLinus Torvalds If not, cover it anyway. */ 11661da177e4SLinus Torvalds 11671da177e4SLinus Torvalds struct jffs2_raw_node_ref *raw = frag->node->raw; 11681da177e4SLinus Torvalds struct jffs2_eraseblock *jeb; 11691da177e4SLinus Torvalds 11701da177e4SLinus Torvalds jeb = &c->blocks[raw->flash_offset / c->sector_size]; 11711da177e4SLinus Torvalds 11721da177e4SLinus Torvalds if (jeb == c->gcblock) { 11731da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Expanding down to cover frag (0x%x-0x%x) in gcblock at %08x\n", 11741da177e4SLinus Torvalds frag->ofs, frag->ofs+frag->size, ref_offset(raw))); 11751da177e4SLinus Torvalds start = frag->ofs; 11761da177e4SLinus Torvalds break; 11771da177e4SLinus Torvalds } 11781da177e4SLinus Torvalds if (!ISDIRTY(jeb->dirty_size + jeb->wasted_size)) { 11791da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Not expanding down to cover frag (0x%x-0x%x) in clean block %08x\n", 11801da177e4SLinus Torvalds frag->ofs, frag->ofs+frag->size, jeb->offset)); 11811da177e4SLinus Torvalds break; 11821da177e4SLinus Torvalds } 11831da177e4SLinus Torvalds 11841da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Expanding down to cover frag (0x%x-0x%x) in dirty block %08x\n", 11851da177e4SLinus Torvalds frag->ofs, frag->ofs+frag->size, jeb->offset)); 11861da177e4SLinus Torvalds start = frag->ofs; 11871da177e4SLinus Torvalds break; 11881da177e4SLinus Torvalds } 11891da177e4SLinus Torvalds } 11901da177e4SLinus Torvalds 11911da177e4SLinus Torvalds /* ... then up */ 11921da177e4SLinus Torvalds 11931da177e4SLinus Torvalds /* Find last frag which is actually part of the node we're to GC. */ 11941da177e4SLinus Torvalds frag = jffs2_lookup_node_frag(&f->fragtree, end-1); 11951da177e4SLinus Torvalds 11961da177e4SLinus Torvalds while((frag = frag_next(frag)) && frag->ofs+frag->size <= max) { 11971da177e4SLinus Torvalds 11981da177e4SLinus Torvalds /* If the previous frag doesn't even reach the beginning, there's lots 11991da177e4SLinus Torvalds of fragmentation. Just merge. */ 12001da177e4SLinus Torvalds if (frag->ofs+frag->size < max) { 12011da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Expanding up to cover partial frag (0x%x-0x%x)\n", 12021da177e4SLinus Torvalds frag->ofs, frag->ofs+frag->size)); 12031da177e4SLinus Torvalds end = frag->ofs + frag->size; 12041da177e4SLinus Torvalds continue; 12051da177e4SLinus Torvalds } 12061da177e4SLinus Torvalds 12071da177e4SLinus Torvalds if (!frag->node || !frag->node->raw) { 12081da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Last frag in page is hole (0x%x-0x%x). Not expanding up.\n", 12091da177e4SLinus Torvalds frag->ofs, frag->ofs+frag->size)); 12101da177e4SLinus Torvalds break; 12111da177e4SLinus Torvalds } else { 12121da177e4SLinus Torvalds 12131da177e4SLinus Torvalds /* OK, it's a frag which extends to the beginning of the page. Does it live 12141da177e4SLinus Torvalds in a block which is still considered clean? If so, don't obsolete it. 12151da177e4SLinus Torvalds If not, cover it anyway. */ 12161da177e4SLinus Torvalds 12171da177e4SLinus Torvalds struct jffs2_raw_node_ref *raw = frag->node->raw; 12181da177e4SLinus Torvalds struct jffs2_eraseblock *jeb; 12191da177e4SLinus Torvalds 12201da177e4SLinus Torvalds jeb = &c->blocks[raw->flash_offset / c->sector_size]; 12211da177e4SLinus Torvalds 12221da177e4SLinus Torvalds if (jeb == c->gcblock) { 12231da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Expanding up to cover frag (0x%x-0x%x) in gcblock at %08x\n", 12241da177e4SLinus Torvalds frag->ofs, frag->ofs+frag->size, ref_offset(raw))); 12251da177e4SLinus Torvalds end = frag->ofs + frag->size; 12261da177e4SLinus Torvalds break; 12271da177e4SLinus Torvalds } 12281da177e4SLinus Torvalds if (!ISDIRTY(jeb->dirty_size + jeb->wasted_size)) { 12291da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Not expanding up to cover frag (0x%x-0x%x) in clean block %08x\n", 12301da177e4SLinus Torvalds frag->ofs, frag->ofs+frag->size, jeb->offset)); 12311da177e4SLinus Torvalds break; 12321da177e4SLinus Torvalds } 12331da177e4SLinus Torvalds 12341da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Expanding up to cover frag (0x%x-0x%x) in dirty block %08x\n", 12351da177e4SLinus Torvalds frag->ofs, frag->ofs+frag->size, jeb->offset)); 12361da177e4SLinus Torvalds end = frag->ofs + frag->size; 12371da177e4SLinus Torvalds break; 12381da177e4SLinus Torvalds } 12391da177e4SLinus Torvalds } 12401da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Expanded dnode to write from (0x%x-0x%x) to (0x%x-0x%x)\n", 12411da177e4SLinus Torvalds orig_start, orig_end, start, end)); 12421da177e4SLinus Torvalds 12438557fd51SArtem B. Bityuckiy D1(BUG_ON(end > frag_last(&f->fragtree)->ofs + frag_last(&f->fragtree)->size)); 12441da177e4SLinus Torvalds BUG_ON(end < orig_end); 12451da177e4SLinus Torvalds BUG_ON(start > orig_start); 12461da177e4SLinus Torvalds } 12471da177e4SLinus Torvalds 12481da177e4SLinus Torvalds /* First, use readpage() to read the appropriate page into the page cache */ 12491da177e4SLinus Torvalds /* Q: What happens if we actually try to GC the _same_ page for which commit_write() 12501da177e4SLinus Torvalds * triggered garbage collection in the first place? 12511da177e4SLinus Torvalds * A: I _think_ it's OK. read_cache_page shouldn't deadlock, we'll write out the 12521da177e4SLinus Torvalds * page OK. We'll actually write it out again in commit_write, which is a little 12531da177e4SLinus Torvalds * suboptimal, but at least we're correct. 12541da177e4SLinus Torvalds */ 12551da177e4SLinus Torvalds pg_ptr = jffs2_gc_fetch_page(c, f, start, &pg); 12561da177e4SLinus Torvalds 12571da177e4SLinus Torvalds if (IS_ERR(pg_ptr)) { 12581da177e4SLinus Torvalds printk(KERN_WARNING "read_cache_page() returned error: %ld\n", PTR_ERR(pg_ptr)); 12591da177e4SLinus Torvalds return PTR_ERR(pg_ptr); 12601da177e4SLinus Torvalds } 12611da177e4SLinus Torvalds 12621da177e4SLinus Torvalds offset = start; 12631da177e4SLinus Torvalds while(offset < orig_end) { 12641da177e4SLinus Torvalds uint32_t datalen; 12651da177e4SLinus Torvalds uint32_t cdatalen; 12661da177e4SLinus Torvalds uint16_t comprtype = JFFS2_COMPR_NONE; 12671da177e4SLinus Torvalds 12689fe4854cSDavid Woodhouse ret = jffs2_reserve_space_gc(c, sizeof(ri) + JFFS2_MIN_DATA_LEN, 1269e631ddbaSFerenc Havasi &alloclen, JFFS2_SUMMARY_INODE_SIZE); 12701da177e4SLinus Torvalds 12711da177e4SLinus Torvalds if (ret) { 12721da177e4SLinus Torvalds printk(KERN_WARNING "jffs2_reserve_space_gc of %zd bytes for garbage_collect_dnode failed: %d\n", 12731da177e4SLinus Torvalds sizeof(ri)+ JFFS2_MIN_DATA_LEN, ret); 12741da177e4SLinus Torvalds break; 12751da177e4SLinus Torvalds } 12761da177e4SLinus Torvalds cdatalen = min_t(uint32_t, alloclen - sizeof(ri), end - offset); 12771da177e4SLinus Torvalds datalen = end - offset; 12781da177e4SLinus Torvalds 12791da177e4SLinus Torvalds writebuf = pg_ptr + (offset & (PAGE_CACHE_SIZE -1)); 12801da177e4SLinus Torvalds 12811da177e4SLinus Torvalds comprtype = jffs2_compress(c, f, writebuf, &comprbuf, &datalen, &cdatalen); 12821da177e4SLinus Torvalds 12831da177e4SLinus Torvalds ri.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 12841da177e4SLinus Torvalds ri.nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE); 12851da177e4SLinus Torvalds ri.totlen = cpu_to_je32(sizeof(ri) + cdatalen); 12861da177e4SLinus Torvalds ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4)); 12871da177e4SLinus Torvalds 12881da177e4SLinus Torvalds ri.ino = cpu_to_je32(f->inocache->ino); 12891da177e4SLinus Torvalds ri.version = cpu_to_je32(++f->highest_version); 12901da177e4SLinus Torvalds ri.mode = cpu_to_jemode(JFFS2_F_I_MODE(f)); 12911da177e4SLinus Torvalds ri.uid = cpu_to_je16(JFFS2_F_I_UID(f)); 12921da177e4SLinus Torvalds ri.gid = cpu_to_je16(JFFS2_F_I_GID(f)); 12931da177e4SLinus Torvalds ri.isize = cpu_to_je32(JFFS2_F_I_SIZE(f)); 12941da177e4SLinus Torvalds ri.atime = cpu_to_je32(JFFS2_F_I_ATIME(f)); 12951da177e4SLinus Torvalds ri.ctime = cpu_to_je32(JFFS2_F_I_CTIME(f)); 12961da177e4SLinus Torvalds ri.mtime = cpu_to_je32(JFFS2_F_I_MTIME(f)); 12971da177e4SLinus Torvalds ri.offset = cpu_to_je32(offset); 12981da177e4SLinus Torvalds ri.csize = cpu_to_je32(cdatalen); 12991da177e4SLinus Torvalds ri.dsize = cpu_to_je32(datalen); 13001da177e4SLinus Torvalds ri.compr = comprtype & 0xff; 13011da177e4SLinus Torvalds ri.usercompr = (comprtype >> 8) & 0xff; 13021da177e4SLinus Torvalds ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8)); 13031da177e4SLinus Torvalds ri.data_crc = cpu_to_je32(crc32(0, comprbuf, cdatalen)); 13041da177e4SLinus Torvalds 13059fe4854cSDavid Woodhouse new_fn = jffs2_write_dnode(c, f, &ri, comprbuf, cdatalen, ALLOC_GC); 13061da177e4SLinus Torvalds 13071da177e4SLinus Torvalds jffs2_free_comprbuf(comprbuf, writebuf); 13081da177e4SLinus Torvalds 13091da177e4SLinus Torvalds if (IS_ERR(new_fn)) { 13101da177e4SLinus Torvalds printk(KERN_WARNING "Error writing new dnode: %ld\n", PTR_ERR(new_fn)); 13111da177e4SLinus Torvalds ret = PTR_ERR(new_fn); 13121da177e4SLinus Torvalds break; 13131da177e4SLinus Torvalds } 13141da177e4SLinus Torvalds ret = jffs2_add_full_dnode_to_inode(c, f, new_fn); 13151da177e4SLinus Torvalds offset += datalen; 13161da177e4SLinus Torvalds if (f->metadata) { 13171da177e4SLinus Torvalds jffs2_mark_node_obsolete(c, f->metadata->raw); 13181da177e4SLinus Torvalds jffs2_free_full_dnode(f->metadata); 13191da177e4SLinus Torvalds f->metadata = NULL; 13201da177e4SLinus Torvalds } 13211da177e4SLinus Torvalds } 13221da177e4SLinus Torvalds 13231da177e4SLinus Torvalds jffs2_gc_release_page(c, pg_ptr, &pg); 13241da177e4SLinus Torvalds return ret; 13251da177e4SLinus Torvalds } 1326