X-Git-Url: http://www.aleph1.co.uk/gitweb/?p=yaffs2.git;a=blobdiff_plain;f=yaffs_guts.c;h=385b26778fbff66aa1e872800f4452ae5773ed17;hp=1b0a67f7e6cc78bb7a165ee12f0fefae2b90d32a;hb=c3e035fe74c2aa3bf6ff00aa715a264232cc09a7;hpb=30ab3ff5e311e8e2b488c3f62f30e7450dc6bee9

diff --git a/yaffs_guts.c b/yaffs_guts.c
index 1b0a67f..385b267 100644
--- a/yaffs_guts.c
+++ b/yaffs_guts.c
@@ -1,7 +1,7 @@
 /*
  * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
  *
- * Copyright (C) 2002-2007 Aleph One Ltd.
+ * Copyright (C) 2002-2010 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
  *
  * Created by Charles Manning <charles@aleph1.co.uk>
@@ -10,10 +10,6 @@
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  */
-
-const char *yaffs_guts_c_version =
-    "$Id: yaffs_guts.c,v 1.108 2010-02-18 01:18:04 charles Exp $";
-
 #include "yportenv.h"
 #include "yaffs_trace.h"
 
@@ -33,11 +29,34 @@ const char *yaffs_guts_c_version =
 #include "yaffs_nand.h"
 #include "yaffs_packedtags2.h"
 
+#include "yaffs_nameval.h"
+
+
+/* Note YAFFS_GC_GOOD_ENOUGH must be <= YAFFS_GC_PASSIVE_THRESHOLD */
+#define YAFFS_GC_GOOD_ENOUGH 2
+#define YAFFS_GC_PASSIVE_THRESHOLD 4
 
-#define YAFFS_PASSIVE_GC_CHUNKS 2
+#define YAFFS_SMALL_HOLE_THRESHOLD 3
+
+/*
+ * Checkpoints are really no benefit on very small partitions.
+ *
+ * To save space on small partitions don't bother with checkpoints unless
+ * the partition is at least this big.
+ */
+#define YAFFS_CHECKPOINT_MIN_BLOCKS 60
 
 #include "yaffs_ecc.h"
 
+/* Private structure for doing xattr modifications */
+typedef struct {
+	int set; /* If 0 then this is a deletion */
+	const char *name;
+	const void *data;
+	int size;
+	int flags;
+	int result;
+} yaffs_XAttrMod;
 
 /* Robustification (if it ever comes about...) */
 static void yaffs_RetireBlock(yaffs_Device *dev, int blockInNAND);
@@ -68,11 +87,11 @@ static yaffs_Object *yaffs_CreateNewObject(yaffs_Device *dev, int number,
 static void yaffs_AddObjectToDirectory(yaffs_Object *directory,
 				yaffs_Object *obj);
 static int yaffs_UpdateObjectHeader(yaffs_Object *in, const YCHAR *name,
-				int force, int isShrink, int shadows);
+				int force, int isShrink, int shadows, yaffs_XAttrMod *xop);
+static int yaffs_ApplyXMod(yaffs_Device *dev, char *buffer, yaffs_XAttrMod *xmod);
+
 static void yaffs_RemoveObjectFromDirectory(yaffs_Object *obj);
 static int yaffs_CheckStructures(void);
-static int yaffs_DeleteWorker(yaffs_Object *in, yaffs_Tnode *tn, __u32 level,
-			int chunkOffset, int *limit);
 static int yaffs_DoGenericObjectDeletion(yaffs_Object *in);
 
 static yaffs_BlockInfo *yaffs_GetBlockInfo(yaffs_Device *dev, int blockNo);
@@ -114,6 +133,7 @@ static yaffs_Tnode *yaffs_FindLevel0Tnode(yaffs_Device *dev,
 					yaffs_FileStructure *fStruct,
 					__u32 chunkId);
 
+static int yaffs_HandleHole(yaffs_Object *obj, loff_t newSize);
 static void yaffs_SkipRestOfBlock(yaffs_Device *dev);
 static int yaffs_VerifyChunkWritten(yaffs_Device *dev,
 					int chunkInNAND,
@@ -179,7 +199,7 @@ static __u32 ShiftsGE(__u32 x)
 
 static __u32 Shifts(__u32 x)
 {
-	int nShifts;
+	__u32 nShifts;
 
 	nShifts =  0;
 
@@ -404,16 +424,19 @@ static int yaffs_CountChunkBits(yaffs_Device *dev, int blk)
 
 static int yaffs_SkipVerification(yaffs_Device *dev)
 {
+	dev=dev;
 	return !(yaffs_traceMask & (YAFFS_TRACE_VERIFY | YAFFS_TRACE_VERIFY_FULL));
 }
 
 static int yaffs_SkipFullVerification(yaffs_Device *dev)
 {
+	dev=dev;
 	return !(yaffs_traceMask & (YAFFS_TRACE_VERIFY_FULL));
 }
 
 static int yaffs_SkipNANDVerification(yaffs_Device *dev)
 {
+	dev=dev;
 	return !(yaffs_traceMask & (YAFFS_TRACE_VERIFY_NAND));
 }
 
@@ -603,7 +626,8 @@ static void yaffs_VerifyObjectHeader(yaffs_Object *obj, yaffs_ObjectHeader *oh,
 }
 
 
-
+#if 0
+/* Not being used, but don't want to throw away yet */
 static int yaffs_VerifyTnodeWorker(yaffs_Object *obj, yaffs_Tnode *tn,
 					__u32 level, int chunkOffset)
 {
@@ -649,6 +673,7 @@ static int yaffs_VerifyTnodeWorker(yaffs_Object *obj, yaffs_Tnode *tn,
 
 }
 
+#endif
 
 static void yaffs_VerifyFile(yaffs_Object *obj)
 {
@@ -682,12 +707,6 @@ static void yaffs_VerifyFile(yaffs_Object *obj)
 
 	actualTallness = obj->variant.fileVariant.topLevel;
 
-	if (requiredTallness > actualTallness)
-		T(YAFFS_TRACE_VERIFY,
-		(TSTR("Obj %d had tnode tallness %d, needs to be %d"TENDSTR),
-		 obj->objectId, actualTallness, requiredTallness));
-
-
 	/* Check that the chunks in the tnode tree are all correct.
 	 * We do this by scanning through the tnode tree and
 	 * checking the tags for every chunk match.
@@ -1050,6 +1069,85 @@ static int yaffs_WriteNewChunkWithTagsToNAND(struct yaffs_DeviceStruct *dev,
 	return chunk;
 }
 
+
+/*
+ * Oldest Dirty Sequence Number handling.
+ */
+ 
+/* yaffs_CalcOldestDirtySequence()
+ * yaffs_FindOldestDirtySequence()
+ * Calculate the oldest dirty sequence number if we don't know it.
+ */
+static void yaffs_CalcOldestDirtySequence(yaffs_Device *dev)
+{
+	int i;
+	unsigned seq;
+	unsigned blockNo = 0;
+	yaffs_BlockInfo *b;
+
+	if(!dev->param.isYaffs2)
+		return;
+
+	/* Find the oldest dirty sequence number. */
+	seq = dev->sequenceNumber + 1;
+	b = dev->blockInfo;
+	for (i = dev->internalStartBlock; i <= dev->internalEndBlock; i++) {
+		if (b->blockState == YAFFS_BLOCK_STATE_FULL &&
+			(b->pagesInUse - b->softDeletions) < dev->param.nChunksPerBlock &&
+			b->sequenceNumber < seq) {
+			seq = b->sequenceNumber;
+			blockNo = i;
+		}
+		b++;
+	}
+
+	if(blockNo){
+		dev->oldestDirtySequence = seq;
+		dev->oldestDirtyBlock = blockNo;
+	}
+
+}
+
+
+static void yaffs_FindOldestDirtySequence(yaffs_Device *dev)
+{
+	if(dev->param.isYaffs2 && !dev->oldestDirtySequence)
+		yaffs_CalcOldestDirtySequence(dev);
+}
+
+/*
+ * yaffs_ClearOldestDirtySequence()
+ * Called when a block is erased or marked bad. (ie. when its sequenceNumber
+ * becomes invalid). If the value matches the oldest then we clear 
+ * dev->oldestDirtySequence to force its recomputation.
+ */
+static void yaffs_ClearOldestDirtySequence(yaffs_Device *dev, yaffs_BlockInfo *bi)
+{
+
+	if(!dev->param.isYaffs2)
+		return;
+
+	if(!bi || bi->sequenceNumber == dev->oldestDirtySequence){
+		dev->oldestDirtySequence = 0;
+		dev->oldestDirtyBlock = 0;
+	}
+}
+
+/*
+ * yaffs_UpdateOldestDirtySequence()
+ * Update the oldest dirty sequence number whenever we dirty a block.
+ * Only do this if the oldestDirtySequence is actually being tracked.
+ */
+static void yaffs_UpdateOldestDirtySequence(yaffs_Device *dev, unsigned blockNo, yaffs_BlockInfo *bi)
+{
+	if(dev->param.isYaffs2 && dev->oldestDirtySequence){
+		if(dev->oldestDirtySequence > bi->sequenceNumber){
+			dev->oldestDirtySequence = bi->sequenceNumber;
+			dev->oldestDirtyBlock = blockNo;
+		}
+	}
+}
+ 
 /*
  * Block retiring for handling a broken block.
  */
@@ -1059,6 +1157,8 @@ static void yaffs_RetireBlock(yaffs_Device *dev, int blockInNAND)
 	yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, blockInNAND);
 
 	yaffs_InvalidateCheckpoint(dev);
+	
+	yaffs_ClearOldestDirtySequence(dev,bi);
 
 	if (yaffs_MarkBlockBad(dev, blockInNAND) != YAFFS_OK) {
 		if (yaffs_EraseBlockInNAND(dev, blockInNAND) != YAFFS_OK) {
@@ -1100,11 +1200,18 @@ static void yaffs_HandleWriteChunkOk(yaffs_Device *dev, int chunkInNAND,
 				const __u8 *data,
 				const yaffs_ExtendedTags *tags)
 {
+	dev=dev;
+	chunkInNAND=chunkInNAND;
+	data=data;
+	tags=tags;
 }
 
 static void yaffs_HandleUpdateChunk(yaffs_Device *dev, int chunkInNAND,
 				const yaffs_ExtendedTags *tags)
 {
+	dev=dev;
+	chunkInNAND=chunkInNAND;
+	tags=tags;
 }
 
 void yaffs_HandleChunkError(yaffs_Device *dev, yaffs_BlockInfo *bi)
@@ -1452,6 +1559,8 @@ static yaffs_Tnode *yaffs_FindLevel0Tnode(yaffs_Device *dev,
 	int requiredTallness;
 	int level = fStruct->topLevel;
 
+	dev=dev;
+
 	/* Check sane level and chunk Id */
 	if (level < 0 || level > YAFFS_TNODES_MAX_LEVEL)
 		return NULL;
@@ -1617,9 +1726,10 @@ static int yaffs_FindChunkInGroup(yaffs_Device *dev, int theChunk,
 	return -1;
 }
 
-
+#if 0
+/* Experimental code not being used yet. Might speed up file deletion */
 /* DeleteWorker scans backwards through the tnode tree and deletes all the
- * chunks and tnodes in the file
+ * chunks and tnodes in the file.
  * Returns 1 if the tree was deleted.
  * Returns 0 if it stopped early due to hitting the limit and the delete is incomplete.
  */
@@ -1711,16 +1821,21 @@ static int yaffs_DeleteWorker(yaffs_Object *in, yaffs_Tnode *tn, __u32 level,
 
 }
 
+#endif
+
 static void yaffs_SoftDeleteChunk(yaffs_Device *dev, int chunk)
 {
 	yaffs_BlockInfo *theBlock;
+	unsigned blockNo;
 
 	T(YAFFS_TRACE_DELETION, (TSTR("soft delete chunk %d" TENDSTR), chunk));
 
-	theBlock = yaffs_GetBlockInfo(dev, chunk / dev->param.nChunksPerBlock);
+	blockNo =  chunk / dev->param.nChunksPerBlock;
+	theBlock = yaffs_GetBlockInfo(dev, blockNo);
 	if (theBlock) {
 		theBlock->softDeletions++;
 		dev->nFreeChunks++;
+		yaffs_UpdateOldestDirtySequence(dev, blockNo, theBlock);
 	}
 }
 
@@ -2135,33 +2250,21 @@ static void yaffs_InitialiseObjects(yaffs_Device *dev)
 
 static int yaffs_FindNiceObjectBucket(yaffs_Device *dev)
 {
-	static int x;
 	int i;
 	int l = 999;
 	int lowest = 999999;
 
-	/* First let's see if we can find one that's empty. */
-
-	for (i = 0; i < 10 && lowest > 0; i++) {
-		x++;
-		x %= YAFFS_NOBJECT_BUCKETS;
-		if (dev->objectBucket[x].count < lowest) {
-			lowest = dev->objectBucket[x].count;
-			l = x;
-		}
-
-	}
 
-	/* If we didn't find an empty list, then try
-	 * looking a bit further for a short one
+	/* Search for the shortest list or one that
+	 * isn't too long.
 	 */
 
-	for (i = 0; i < 10 && lowest > 3; i++) {
-		x++;
-		x %= YAFFS_NOBJECT_BUCKETS;
-		if (dev->objectBucket[x].count < lowest) {
-			lowest = dev->objectBucket[x].count;
-			l = x;
+	for (i = 0; i < 10 && lowest > 4; i++) {
+		dev->bucketFinder++;
+		dev->bucketFinder %= YAFFS_NOBJECT_BUCKETS;
+		if (dev->objectBucket[dev->bucketFinder].count < lowest) {
+			lowest = dev->objectBucket[dev->bucketFinder].count;
+			l = dev->bucketFinder;
 		}
 
 	}
@@ -2287,6 +2390,8 @@ yaffs_Object *yaffs_CreateNewObject(yaffs_Device *dev, int number,
 		case YAFFS_OBJECT_TYPE_DIRECTORY:
 			YINIT_LIST_HEAD(&theObject->variant.directoryVariant.
 					children);
+			YINIT_LIST_HEAD(&theObject->variant.directoryVariant.
+					dirty);
 			break;
 		case YAFFS_OBJECT_TYPE_SYMLINK:
 		case YAFFS_OBJECT_TYPE_HARDLINK:
@@ -2427,7 +2532,7 @@ static yaffs_Object *yaffs_MknodObject(yaffs_ObjectType type,
 			break;
 		}
 
-		if (yaffs_UpdateObjectHeader(in, name, 0, 0, 0) < 0) {
+		if (yaffs_UpdateObjectHeader(in, name, 0, 0, 0, NULL) < 0) {
 			/* Could not create the object header, fail the creation */
 			yaffs_DeleteObject(in);
 			in = NULL;
@@ -2535,7 +2640,7 @@ static int yaffs_ChangeObjectName(yaffs_Object *obj, yaffs_Object *newDir,
 			obj->unlinked = 1;
 
 		/* If it is a deletion then we mark it as a shrink for gc purposes. */
-		if (yaffs_UpdateObjectHeader(obj, newName, 0, deleteOp, shadows) >= 0)
+		if (yaffs_UpdateObjectHeader(obj, newName, 0, deleteOp, shadows, NULL) >= 0)
 			return YAFFS_OK;
 	}
 
@@ -2591,12 +2696,12 @@ int yaffs_RenameObject(yaffs_Object *oldDir, const YCHAR *oldName,
 			 * Note we must disable gc otherwise it can mess up the shadowing.
 			 *
 			 */
-			dev->isDoingGC=1;
+			dev->gcDisable=1;
 			yaffs_ChangeObjectName(obj, newDir, newName, force,
 						existingTarget->objectId);
 			existingTarget->isShadowed = 1;
 			yaffs_UnlinkObject(existingTarget);
-			dev->isDoingGC=0;
+			dev->gcDisable=0;
 		}
 
 		result = yaffs_ChangeObjectName(obj, newDir, newName, 1, 0);
@@ -2671,9 +2776,6 @@ static void yaffs_DeinitialiseBlocks(yaffs_Device *dev)
 static int yaffs_BlockNotDisqualifiedFromGC(yaffs_Device *dev,
 					yaffs_BlockInfo *bi)
 {
-	int i;
-	__u32 seq;
-	yaffs_BlockInfo *b;
 
 	if (!dev->param.isYaffs2)
 		return 1;	/* disqualification only applies to yaffs2. */
@@ -2681,23 +2783,7 @@ static int yaffs_BlockNotDisqualifiedFromGC(yaffs_Device *dev,
 	if (!bi->hasShrinkHeader)
 		return 1;	/* can gc */
 
-	/* Find the oldest dirty sequence number if we don't know it and save it
-	 * so we don't have to keep recomputing it.
-	 */
-	if (!dev->oldestDirtySequence) {
-		seq = dev->sequenceNumber;
-
-		for (i = dev->internalStartBlock; i <= dev->internalEndBlock;
-				i++) {
-			b = yaffs_GetBlockInfo(dev, i);
-			if (b->blockState == YAFFS_BLOCK_STATE_FULL &&
-			    (b->pagesInUse - b->softDeletions) <
-			    dev->param.nChunksPerBlock && b->sequenceNumber < seq) {
-				seq = b->sequenceNumber;
-			}
-		}
-		dev->oldestDirtySequence = seq;
-	}
+	yaffs_FindOldestDirtySequence(dev);
 
 	/* Can't do gc of this block if there are any blocks older than this one that have
 	 * discarded pages.
@@ -2705,109 +2791,67 @@ static int yaffs_BlockNotDisqualifiedFromGC(yaffs_Device *dev,
 	return (bi->sequenceNumber <= dev->oldestDirtySequence);
 }
 
-/* FindDiretiestBlock is used to select the dirtiest block (or close enough)
- * for garbage collection.
+/*
+ * yaffs_FindRefreshBlock()
+ * periodically finds the oldest full block by sequence number for refreshing.
+ * Only for yaffs2.
  */
-
-static int yaffs_FindBlockForGarbageCollection(yaffs_Device *dev,
-					int aggressive)
+static __u32 yaffs_FindRefreshBlock(yaffs_Device *dev)
 {
-	int b = dev->currentDirtyChecker;
-
-	int i;
-	int iterations;
-	int dirtiest = -1;
-	int pagesInUse = 0;
-	int prioritised = 0;
-	yaffs_BlockInfo *bi;
-	int pendingPrioritisedExist = 0;
-
-	/* First let's see if we need to grab a prioritised block */
-	if (dev->hasPendingPrioritisedGCs) {
-		for (i = dev->internalStartBlock; i < dev->internalEndBlock && !prioritised; i++) {
+	__u32 b ;
 
-			bi = yaffs_GetBlockInfo(dev, i);
-			/* yaffs_VerifyBlock(dev,bi,i); */
+	__u32 oldest = 0;
+	__u32 oldestSequence = 0;
 
-			if (bi->gcPrioritise) {
-				pendingPrioritisedExist = 1;
-				if (bi->blockState == YAFFS_BLOCK_STATE_FULL &&
-				   yaffs_BlockNotDisqualifiedFromGC(dev, bi)) {
-					pagesInUse = (bi->pagesInUse - bi->softDeletions);
-					dirtiest = i;
-					prioritised = 1;
-					aggressive = 1; /* Fool the non-aggressive skip logiv below */
-				}
-			}
-		}
-
-		if (!pendingPrioritisedExist) /* None found, so we can clear this */
-			dev->hasPendingPrioritisedGCs = 0;
-	}
+	yaffs_BlockInfo *bi;
 
-	/* If we're doing aggressive GC then we are happy to take a less-dirty block, and
-	 * search harder.
-	 * else (we're doing a leasurely gc), then we only bother to do this if the
-	 * block has only a few pages in use.
+	/*
+	 * If refresh period < 10 then refreshing is disabled.
 	 */
+	if(dev->param.refreshPeriod < 10 ||
+		!dev->param.isYaffs2)
+	        return oldest;
 
-	dev->nonAggressiveSkip--;
+        /*
+         * Fix broken values.
+         */
+        if(dev->refreshSkip > dev->param.refreshPeriod)
+                dev->refreshSkip = dev->param.refreshPeriod;
 
-	if (!aggressive && (dev->nonAggressiveSkip > 0))
-		return -1;
-
-	if (!prioritised)
-		pagesInUse =
-			(aggressive) ? dev->param.nChunksPerBlock : YAFFS_PASSIVE_GC_CHUNKS + 1;
+	if(dev->refreshSkip > 0)
+	        return oldest;
 
-	if (aggressive)
-		iterations =
-		    dev->internalEndBlock - dev->internalStartBlock + 1;
-	else {
-		iterations =
-		    dev->internalEndBlock - dev->internalStartBlock + 1;
-		iterations = iterations / 16;
-		if (iterations > 200)
-			iterations = 200;
-	}
-
-	for (i = 0; i <= iterations && pagesInUse > 0 && !prioritised; i++) {
-		b++;
-		if (b < dev->internalStartBlock || b > dev->internalEndBlock)
-			b = dev->internalStartBlock;
-
-		if (b < dev->internalStartBlock || b > dev->internalEndBlock) {
-			T(YAFFS_TRACE_ERROR,
-			  (TSTR("**>> Block %d is not valid" TENDSTR), b));
-			YBUG();
-		}
+	/*
+	 * Refresh skip is now zero.
+	 * We'll do a refresh this time around....
+	 * Update the refresh skip and find the oldest block.
+	 */
+	dev->refreshSkip = dev->param.refreshPeriod;
+	dev->refreshCount++;
+	bi = dev->blockInfo;
+	for (b = dev->internalStartBlock; b <=dev->internalEndBlock; b++){
 
-		bi = yaffs_GetBlockInfo(dev, b);
+		if (bi->blockState == YAFFS_BLOCK_STATE_FULL){
 
-		if (bi->blockState == YAFFS_BLOCK_STATE_FULL &&
-			(bi->pagesInUse - bi->softDeletions) < pagesInUse &&
-				yaffs_BlockNotDisqualifiedFromGC(dev, bi)) {
-			dirtiest = b;
-			pagesInUse = (bi->pagesInUse - bi->softDeletions);
+			if(oldest < 1 ||
+                                bi->sequenceNumber < oldestSequence){
+                                oldest = b;
+                                oldestSequence = bi->sequenceNumber;
+                        }
 		}
+		bi++;
 	}
 
-	dev->currentDirtyChecker = b;
-
-	if (dirtiest > 0) {
+	if (oldest > 0) {
 		T(YAFFS_TRACE_GC,
-		  (TSTR("GC Selected block %d with %d free, prioritised:%d" TENDSTR), dirtiest,
-		   dev->param.nChunksPerBlock - pagesInUse, prioritised));
+		  (TSTR("GC refresh count %d selected block %d with sequenceNumber %d" TENDSTR),
+		   dev->refreshCount, oldest, oldestSequence));
 	}
 
-	dev->oldestDirtySequence = 0;
-
-	if (dirtiest > 0)
-		dev->nonAggressiveSkip = 4;
-
-	return dirtiest;
+	return oldest;
 }
 
+
 static void yaffs_BlockBecameDirty(yaffs_Device *dev, int blockNo)
 {
 	yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, blockNo);
@@ -2822,8 +2866,20 @@ static void yaffs_BlockBecameDirty(yaffs_Device *dev, int blockNo)
 		(TSTR("yaffs_BlockBecameDirty block %d state %d %s"TENDSTR),
 		blockNo, bi->blockState, (bi->needsRetiring) ? "needs retiring" : ""));
 
+	yaffs_ClearOldestDirtySequence(dev,bi);
+
 	bi->blockState = YAFFS_BLOCK_STATE_DIRTY;
 
+	/* If this is the block being garbage collected then stop gc'ing this block */
+	if(blockNo == dev->gcBlock)
+		dev->gcBlock = 0;
+
+	/* If this block is currently the best candidate for gc then drop as a candidate */
+	if(blockNo == dev->gcDirtiest){
+		dev->gcDirtiest = 0;
+		dev->gcPagesInUse = 0;
+	}
+
 	if (!bi->needsRetiring) {
 		yaffs_InvalidateCheckpoint(dev);
 		erasedOk = yaffs_EraseBlockInNAND(dev, blockNo);
@@ -2851,6 +2907,7 @@ static void yaffs_BlockBecameDirty(yaffs_Device *dev, int blockNo)
 	if (erasedOk) {
 		/* Clean it up... */
 		bi->blockState = YAFFS_BLOCK_STATE_EMPTY;
+		bi->sequenceNumber = 0;
 		dev->nErasedBlocks++;
 		bi->pagesInUse = 0;
 		bi->softDeletions = 0;
@@ -2920,10 +2977,17 @@ static int yaffs_FindBlockForAllocation(yaffs_Device *dev)
 
 
 
+static int yaffs_CheckpointRequired(yaffs_Device *dev)
+{
+	int nblocks = dev->internalEndBlock - dev->internalStartBlock + 1 ;
+	return dev->param.isYaffs2 &&
+		!dev->param.skipCheckpointWrite &&
+		(nblocks >= YAFFS_CHECKPOINT_MIN_BLOCKS);
+}
 static int yaffs_CalcCheckpointBlocksRequired(yaffs_Device *dev)
 {
 	if (!dev->nCheckpointBlocksRequired &&
-	   dev->param.isYaffs2) {
+		yaffs_CheckpointRequired(dev)){
 		/* Not a valid value so recalculate */
 		int nBytes = 0;
 		int nBlocks;
@@ -2953,7 +3017,7 @@ static int yaffs_CalcCheckpointBlocksRequired(yaffs_Device *dev)
  * Check if there's space to allocate...
  * Thinks.... do we need top make this ths same as yaffs_GetFreeChunks()?
  */
-static int yaffs_CheckSpaceForAllocation(yaffs_Device *dev)
+static int yaffs_CheckSpaceForAllocation(yaffs_Device *dev, int nChunks)
 {
 	int reservedChunks;
 	int reservedBlocks = dev->param.nReservedBlocks;
@@ -2970,7 +3034,7 @@ static int yaffs_CheckSpaceForAllocation(yaffs_Device *dev)
 
 	reservedChunks = ((reservedBlocks + checkpointBlocks) * dev->param.nChunksPerBlock);
 
-	return (dev->nFreeChunks > reservedChunks);
+	return (dev->nFreeChunks > (reservedChunks + nChunks));
 }
 
 static int yaffs_AllocateChunk(yaffs_Device *dev, int useReserve,
@@ -2985,7 +3049,7 @@ static int yaffs_AllocateChunk(yaffs_Device *dev, int useReserve,
 		dev->allocationPage = 0;
 	}
 
-	if (!useReserve && !yaffs_CheckSpaceForAllocation(dev)) {
+	if (!useReserve && !yaffs_CheckSpaceForAllocation(dev, 1)) {
 		/* Not enough space to allocate unless we're allowed to use the reserve. */
 		return -1;
 	}
@@ -3095,13 +3159,7 @@ static int yaffs_GarbageCollectBlock(yaffs_Device *dev, int block,
 	
 	bi->hasShrinkHeader = 0;	/* clear the flag so that the block can erase */
 
-	/* Take off the number of soft deleted entries because
-	 * they're going to get really deleted during GC.
-	 */
-	if(dev->gcChunk == 0) /* first time through for this block */
-		dev->nFreeChunks -= bi->softDeletions;
-
-	dev->isDoingGC = 1;
+	dev->gcDisable = 1;
 
 	if (isCheckpointBlock ||
 			!yaffs_StillSomeChunkBits(dev, block)) {
@@ -3116,7 +3174,7 @@ static int yaffs_GarbageCollectBlock(yaffs_Device *dev, int block,
 
 		yaffs_VerifyBlock(dev, bi, block);
 
-		maxCopies = (wholeBlock) ? dev->param.nChunksPerBlock : 10;
+		maxCopies = (wholeBlock) ? dev->param.nChunksPerBlock : 5;
 		oldChunk = block * dev->param.nChunksPerBlock + dev->gcChunk;
 
 		for (/* init already done */;
@@ -3180,6 +3238,13 @@ static int yaffs_GarbageCollectBlock(yaffs_Device *dev, int block,
 					 * No need to copy this, just forget about it and
 					 * fix up the object.
 					 */
+					 
+					/* Free chunks already includes softdeleted chunks.
+					 * How ever this chunk is going to soon be really deleted
+					 * which will increment free chunks.
+					 * We have to decrement free chunks so this works out properly.
+					 */
+					dev->nFreeChunks--;
 
 					object->nDataChunks--;
 
@@ -3222,17 +3287,26 @@ static int yaffs_GarbageCollectBlock(yaffs_Device *dev, int block,
 
 						yaffs_ObjectHeader *oh;
 						oh = (yaffs_ObjectHeader *)buffer;
+
 						oh->isShrink = 0;
 						tags.extraIsShrinkHeader = 0;
+
 						oh->shadowsObject = 0;
 						oh->inbandShadowsObject = 0;
 						tags.extraShadows = 0;
 
-						yaffs_VerifyObjectHeader(object, oh, &tags, 1);
-					}
+						/* Update file size */
+						if(object->variantType == YAFFS_OBJECT_TYPE_FILE){
+							oh->fileSize = object->variant.fileVariant.fileSize;
+							tags.extraFileLength = oh->fileSize;
+						}
 
-					newChunk =
-					    yaffs_WriteNewChunkWithTagsToNAND(dev, buffer, &tags, 1);
+						yaffs_VerifyObjectHeader(object, oh, &tags, 1);
+						newChunk =
+						    yaffs_WriteNewChunkWithTagsToNAND(dev,(__u8 *) oh, &tags, 1);
+					} else
+						newChunk =
+						    yaffs_WriteNewChunkWithTagsToNAND(dev, buffer, &tags, 1);
 
 					if (newChunk < 0) {
 						retVal = YAFFS_FAIL;
@@ -3289,25 +3363,182 @@ static int yaffs_GarbageCollectBlock(yaffs_Device *dev, int block,
 
 	yaffs_VerifyCollectedBlock(dev, bi, block);
 
-	chunksAfter = yaffs_GetErasedChunks(dev);
-	if (chunksBefore >= chunksAfter) {
-		T(YAFFS_TRACE_GC,
-		  (TSTR
-		   ("gc did not increase free chunks before %d after %d"
-		    TENDSTR), chunksBefore, chunksAfter));
-	}
 
-	/* If the gc completed then clear the current gcBlock so that we find another. */
-	if (bi->blockState != YAFFS_BLOCK_STATE_COLLECTING) {
-		dev->gcBlock = -1;
+
+	if (bi->blockState == YAFFS_BLOCK_STATE_COLLECTING) {
+		/*
+		 * The gc did not complete. Set block state back to FULL
+		 * because checkpointing does not restore gc.
+		 */
+		bi->blockState = YAFFS_BLOCK_STATE_FULL;
+	} else {
+		/* The gc completed. */
+		chunksAfter = yaffs_GetErasedChunks(dev);
+		if (chunksBefore >= chunksAfter) {
+			T(YAFFS_TRACE_GC,
+			  (TSTR
+			   ("gc did not increase free chunks before %d after %d"
+			    TENDSTR), chunksBefore, chunksAfter));
+		}
+		dev->gcBlock = 0;
 		dev->gcChunk = 0;
 	}
 
-	dev->isDoingGC = 0;
+	dev->gcDisable = 0;
 
 	return retVal;
 }
 
+/*
+ * FindBlockForgarbageCollection is used to select the dirtiest block (or close enough)
+ * for garbage collection.
+ */
+
+static unsigned yaffs_FindBlockForGarbageCollection(yaffs_Device *dev,
+					int aggressive,
+					int background)
+{
+	int i;
+	int iterations;
+	unsigned selected = 0;
+	int prioritised = 0;
+	int prioritisedExists = 0;
+	yaffs_BlockInfo *bi;
+	int threshold;
+
+	/* First let's see if we need to grab a prioritised block */
+	if (dev->hasPendingPrioritisedGCs && !aggressive) {
+		dev->gcDirtiest = 0;
+		bi = dev->blockInfo;
+		for (i = dev->internalStartBlock;
+			i <= dev->internalEndBlock && !selected;
+			i++) {
+
+			if (bi->gcPrioritise) {
+				prioritisedExists = 1;
+				if (bi->blockState == YAFFS_BLOCK_STATE_FULL &&
+				   yaffs_BlockNotDisqualifiedFromGC(dev, bi)) {
+					selected = i;
+					prioritised = 1;
+				}
+			}
+			bi++;
+		}
+
+		/*
+		 * If there is a prioritised block and none was selected then
+		 * this happened because there is at least one old dirty block gumming
+		 * up the works. Let's gc the oldest dirty block.
+		 */
+
+		if(prioritisedExists &&
+			!selected &&
+			dev->oldestDirtyBlock > 0)
+			selected = dev->oldestDirtyBlock;
+
+		if (!prioritisedExists) /* None found, so we can clear this */
+			dev->hasPendingPrioritisedGCs = 0;
+	}
+
+	/* If we're doing aggressive GC then we are happy to take a less-dirty block, and
+	 * search harder.
+	 * else (we're doing a leasurely gc), then we only bother to do this if the
+	 * block has only a few pages in use.
+	 */
+
+	if (!selected){
+		int pagesUsed;
+		int nBlocks = dev->internalEndBlock - dev->internalStartBlock + 1;
+		if (aggressive){
+			threshold = dev->param.nChunksPerBlock;
+			iterations = nBlocks;
+		} else {
+			int maxThreshold = dev->param.nChunksPerBlock/2;
+			threshold = background ?
+				(dev->gcNotDone + 2) * 2 : 0;
+			if(threshold <YAFFS_GC_PASSIVE_THRESHOLD)
+				threshold = YAFFS_GC_PASSIVE_THRESHOLD;
+			if(threshold > maxThreshold)
+				threshold = maxThreshold;
+
+			iterations = nBlocks / 16 + 1;
+			if (iterations > 100)
+				iterations = 100;
+		}
+
+		for (i = 0;
+			i < iterations &&
+			(dev->gcDirtiest < 1 ||
+				dev->gcPagesInUse > YAFFS_GC_GOOD_ENOUGH);
+			i++) {
+			dev->gcBlockFinder++;
+			if (dev->gcBlockFinder < dev->internalStartBlock ||
+				dev->gcBlockFinder > dev->internalEndBlock)
+				dev->gcBlockFinder = dev->internalStartBlock;
+
+			bi = yaffs_GetBlockInfo(dev, dev->gcBlockFinder);
+
+			pagesUsed = bi->pagesInUse - bi->softDeletions;
+
+			if (bi->blockState == YAFFS_BLOCK_STATE_FULL &&
+				pagesUsed < dev->param.nChunksPerBlock &&
+				(dev->gcDirtiest < 1 || pagesUsed < dev->gcPagesInUse) &&
+				yaffs_BlockNotDisqualifiedFromGC(dev, bi)) {
+				dev->gcDirtiest = dev->gcBlockFinder;
+				dev->gcPagesInUse = pagesUsed;
+			}
+		}
+
+		if(dev->gcDirtiest > 0 && dev->gcPagesInUse <= threshold)
+			selected = dev->gcDirtiest;
+	}
+
+	/*
+	 * If nothing has been selected for a while, try selecting the oldest dirty
+	 * because that's gumming up the works.
+	 */
+
+	if(!selected && dev->param.isYaffs2 &&
+		dev->gcNotDone >= ( background ? 10 : 20)){
+		yaffs_FindOldestDirtySequence(dev);
+		if(dev->oldestDirtyBlock > 0) {
+			selected = dev->oldestDirtyBlock;
+			dev->gcDirtiest = selected;
+			dev->oldestDirtyGCs++;
+			bi = yaffs_GetBlockInfo(dev, selected);
+			dev->gcPagesInUse =  bi->pagesInUse - bi->softDeletions;
+		} else
+			dev->gcNotDone = 0;
+	}
+
+	if(selected){
+		T(YAFFS_TRACE_GC,
+		  (TSTR("GC Selected block %d with %d free, prioritised:%d" TENDSTR),
+		  selected,
+		  dev->param.nChunksPerBlock - dev->gcPagesInUse,
+		  prioritised));
+
+		if(background)
+			dev->backgroundGCs++;
+		dev->gcDirtiest = 0;
+		dev->gcPagesInUse = 0;
+		dev->gcNotDone = 0;
+		if(dev->refreshSkip > 0)
+			dev->refreshSkip--;
+	} else{
+		dev->gcNotDone++;
+		T(YAFFS_TRACE_GC,
+		  (TSTR("GC none: finder %d skip %d threshold %d dirtiest %d using %d oldest %d%s" TENDSTR),
+		  dev->gcBlockFinder, dev->gcNotDone,
+		  threshold,
+		  dev->gcDirtiest, dev->gcPagesInUse,
+		  dev->oldestDirtyBlock,
+		  background ? " bg" : ""));
+	}
+
+	return selected;
+}
+
 /* New garbage collector
  * If we're very low on erased blocks then we do aggressive garbage collection
  * otherwise we do "leasurely" garbage collection.
@@ -3317,22 +3548,28 @@ static int yaffs_GarbageCollectBlock(yaffs_Device *dev, int block,
  * The idea is to help clear out space in a more spread-out manner.
  * Dunno if it really does anything useful.
  */
-static int yaffs_CheckGarbageCollection(yaffs_Device *dev)
+static int yaffs_CheckGarbageCollection(yaffs_Device *dev, int background)
 {
-	int block;
-	int aggressive;
+	int aggressive = 0;
 	int gcOk = YAFFS_OK;
 	int maxTries = 0;
 
+	int minErased;
+	int erasedChunks;
+
 	int checkpointBlockAdjust;
 
-	if (dev->isDoingGC) {
+	if(dev->param.gcControl &&
+		(dev->param.gcControl(dev) & 1) == 0)
+		return YAFFS_OK;
+
+	if (dev->gcDisable) {
 		/* Bail out so we don't get recursive gc */
 		return YAFFS_OK;
 	}
 
 	/* This loop should pass the first time.
-	 * We'll only see looping here if the erase of the collected block fails.
+	 * We'll only see looping here if the collection does not increase space.
 	 */
 
 	do {
@@ -3342,47 +3579,79 @@ static int yaffs_CheckGarbageCollection(yaffs_Device *dev)
 		if (checkpointBlockAdjust < 0)
 			checkpointBlockAdjust = 0;
 
-		if (dev->nErasedBlocks < (dev->param.nReservedBlocks + checkpointBlockAdjust + 2)) {
-			/* We need a block soon...*/
+		minErased  = dev->param.nReservedBlocks + checkpointBlockAdjust + 1;
+		erasedChunks = dev->nErasedBlocks * dev->param.nChunksPerBlock;
+
+		/* If we need a block soon then do aggressive gc.*/
+		if (dev->nErasedBlocks < minErased)
 			aggressive = 1;
-		} else {
-			/* We're in no hurry */
-			aggressive = 0;
+		else {
+			if(dev->gcSkip > 20)
+				dev->gcSkip = 20;
+			if(erasedChunks < dev->nFreeChunks/2 ||
+				dev->gcSkip < 1 ||
+				background)
+				aggressive = 0;
+			else {
+				dev->gcSkip--;
+				break;
+			}
 		}
 
-		if (dev->gcBlock <= 0) {
-			dev->gcBlock = yaffs_FindBlockForGarbageCollection(dev, aggressive);
+		dev->gcSkip = 5;
+
+                /* If we don't already have a block being gc'd then see if we should start another */
+
+		if (dev->gcBlock < 1 && !aggressive) {
+			dev->gcBlock = yaffs_FindRefreshBlock(dev);
+			dev->gcChunk = 0;
+		}
+		if (dev->gcBlock < 1) {
+			dev->gcBlock = yaffs_FindBlockForGarbageCollection(dev, aggressive, background);
 			dev->gcChunk = 0;
 		}
 
-		block = dev->gcBlock;
-
-		if (block > 0) {
-			dev->garbageCollections++;
+		if (dev->gcBlock > 0) {
+			dev->allGCs++;
 			if (!aggressive)
-				dev->passiveGarbageCollections++;
+				dev->passiveGCs++;
 
 			T(YAFFS_TRACE_GC,
 			  (TSTR
 			   ("yaffs: GC erasedBlocks %d aggressive %d" TENDSTR),
 			   dev->nErasedBlocks, aggressive));
 
-			gcOk = yaffs_GarbageCollectBlock(dev, block, aggressive);
+			gcOk = yaffs_GarbageCollectBlock(dev, dev->gcBlock, aggressive);
 		}
 
-		if (dev->nErasedBlocks < (dev->param.nReservedBlocks) && block > 0) {
+		if (dev->nErasedBlocks < (dev->param.nReservedBlocks) && dev->gcBlock > 0) {
 			T(YAFFS_TRACE_GC,
 			  (TSTR
 			   ("yaffs: GC !!!no reclaim!!! erasedBlocks %d after try %d block %d"
-			    TENDSTR), dev->nErasedBlocks, maxTries, block));
+			    TENDSTR), dev->nErasedBlocks, maxTries, dev->gcBlock));
 		}
 	} while ((dev->nErasedBlocks < dev->param.nReservedBlocks) &&
-		 (block > 0) &&
+		 (dev->gcBlock > 0) &&
 		 (maxTries < 2));
 
 	return aggressive ? gcOk : YAFFS_OK;
 }
 
+/*
+ * yaffs_BackgroundGarbageCollect()
+ * Garbage collects. Intended to be called from a background thread.
+ * Returns non-zero if at least half the free chunks are erased.
+ */
+int yaffs_BackgroundGarbageCollect(yaffs_Device *dev, unsigned urgency)
+{
+	int erasedChunks = dev->nErasedBlocks * dev->param.nChunksPerBlock;
+
+	T(YAFFS_TRACE_BACKGROUND, (TSTR("Background gc %u" TENDSTR),urgency));
+
+	yaffs_CheckGarbageCollection(dev, 1);
+	return erasedChunks > dev->nFreeChunks/2;
+}
+
 /*-------------------------  TAGS --------------------------------*/
 
 static int yaffs_TagsMatch(const yaffs_ExtendedTags *tags, int objectId,
@@ -3685,6 +3954,8 @@ void yaffs_DeleteChunk(yaffs_Device *dev, int chunkId, int markNAND, int lyn)
 			 chunkId));
 
 	bi = yaffs_GetBlockInfo(dev, block);
+	
+	yaffs_UpdateOldestDirtySequence(dev, block, bi);
 
 	T(YAFFS_TRACE_DELETION,
 	  (TSTR("line %d delete of chunk %d" TENDSTR), lyn, chunkId));
@@ -3743,16 +4014,16 @@ static int yaffs_WriteChunkDataToObject(yaffs_Object *in, int chunkInInode,
 
 	yaffs_Device *dev = in->myDev;
 
-	yaffs_CheckGarbageCollection(dev);
+	yaffs_CheckGarbageCollection(dev,0);
 
 	/* Get the previous chunk at this location in the file if it exists.
 	 * If it does not exist then put a zero into the tree. This creates
 	 * the tnode now, rather than later when it is harder to clean up.
 	 */
 	prevChunkId = yaffs_FindChunkInFile(in, chunkInInode, &prevTags);
-	if(prevChunkId <= 0 &&
-		!yaffs_PutChunkIntoFile(in, chunkInInode, 0, 0)){
-	}
+	if(prevChunkId < 1 &&
+		!yaffs_PutChunkIntoFile(in, chunkInInode, 0, 0))
+		return 0;
 
 	/* Set up new tags */
 	yaffs_InitialiseTags(&newTags);
@@ -3769,13 +4040,6 @@ static int yaffs_WriteChunkDataToObject(yaffs_Object *in, int chunkInInode,
 		YBUG();
 	}
 	
-	/*
-	 * If there isn't already a chunk there then do a dummy
-	 * insert to make sue we have the desired tnode structure.
-	 */
-	if(prevChunkId < 1 &&
-		yaffs_PutChunkIntoFile(in, chunkInInode, 0, 0) != YAFFS_OK)
-		return -1;
 		
 	newChunkId =
 	    yaffs_WriteNewChunkWithTagsToNAND(dev, buffer, &newTags,
@@ -3797,7 +4061,7 @@ static int yaffs_WriteChunkDataToObject(yaffs_Object *in, int chunkInInode,
  * If name is not NULL, then that new name is used.
  */
 int yaffs_UpdateObjectHeader(yaffs_Object *in, const YCHAR *name, int force,
-			     int isShrink, int shadows)
+			     int isShrink, int shadows, yaffs_XAttrMod *xmod)
 {
 
 	yaffs_BlockInfo *bi;
@@ -3823,9 +4087,9 @@ int yaffs_UpdateObjectHeader(yaffs_Object *in, const YCHAR *name, int force,
 
 	if (!in->fake ||
 		in == dev->rootDir || /* The rootDir should also be saved */
-		force) {
+		force  || xmod) {
 
-		yaffs_CheckGarbageCollection(dev);
+		yaffs_CheckGarbageCollection(dev,0);
 		yaffs_CheckObjectDetailsLoaded(in);
 
 		buffer = yaffs_GetTempBuffer(in->myDev, __LINE__);
@@ -3840,9 +4104,9 @@ int yaffs_UpdateObjectHeader(yaffs_Object *in, const YCHAR *name, int force,
 			yaffs_VerifyObjectHeader(in, oh, &oldTags, 0);
 
 			memcpy(oldName, oh->name, sizeof(oh->name));
-		}
-
-		memset(buffer, 0xFF, dev->nDataBytesPerChunk);
+			memset(buffer, 0xFF, sizeof(yaffs_ObjectHeader));
+		} else
+			memset(buffer, 0xFF, dev->nDataBytesPerChunk);
 
 		oh->type = in->variantType;
 		oh->yst_mode = in->yst_mode;
@@ -3910,6 +4174,11 @@ int yaffs_UpdateObjectHeader(yaffs_Object *in, const YCHAR *name, int force,
 			break;
 		}
 
+		/* process any xattrib modifications */
+		if(xmod)
+			yaffs_ApplyXMod(dev, (char *)buffer, xmod);
+
+
 		/* Tags */
 		yaffs_InitialiseTags(&newTags);
 		in->serial++;
@@ -4266,7 +4535,6 @@ static void yaffs_DeviceToCheckpointDevice(yaffs_CheckpointDevice *cp,
 	cp->nUnlinkedFiles = dev->nUnlinkedFiles;
 	cp->nBackgroundDeletions = dev->nBackgroundDeletions;
 	cp->sequenceNumber = dev->sequenceNumber;
-	cp->oldestDirtySequence = dev->oldestDirtySequence;
 
 }
 
@@ -4282,7 +4550,6 @@ static void yaffs_CheckpointDeviceToDevice(yaffs_Device *dev,
 	dev->nUnlinkedFiles = cp->nUnlinkedFiles;
 	dev->nBackgroundDeletions = cp->nBackgroundDeletions;
 	dev->sequenceNumber = cp->sequenceNumber;
-	dev->oldestDirtySequence = cp->oldestDirtySequence;
 }
 
 
@@ -4646,7 +4913,7 @@ static int yaffs_WriteCheckpointData(yaffs_Device *dev)
 {
 	int ok = 1;
 
-	if (dev->param.skipCheckpointWrite || !dev->param.isYaffs2) {
+	if (!yaffs_CheckpointRequired(dev)) {
 		T(YAFFS_TRACE_CHECKPOINT, (TSTR("skipping checkpoint write" TENDSTR)));
 		ok = 0;
 	}
@@ -4737,9 +5004,9 @@ static void yaffs_InvalidateCheckpoint(yaffs_Device *dev)
 			dev->blocksInCheckpoint > 0) {
 		dev->isCheckpointed = 0;
 		yaffs_CheckpointInvalidateStream(dev);
-		if (dev->param.markSuperBlockDirty)
-			dev->param.markSuperBlockDirty(dev->context);
 	}
+	if (dev->param.markSuperBlockDirty)
+		dev->param.markSuperBlockDirty(dev);
 }
 
 
@@ -4882,7 +5149,7 @@ int yaffs_ReadDataFromFile(yaffs_Object *in, __u8 *buffer, loff_t offset,
 	return nDone;
 }
 
-int yaffs_WriteDataToFile(yaffs_Object *in, const __u8 *buffer, loff_t offset,
+int yaffs_DoWriteDataToFile(yaffs_Object *in, const __u8 *buffer, loff_t offset,
 			int nBytes, int writeThrough)
 {
 
@@ -4902,8 +5169,6 @@ int yaffs_WriteDataToFile(yaffs_Object *in, const __u8 *buffer, loff_t offset,
 	dev = in->myDev;
 
 	while (n > 0 && chunkWritten >= 0) {
-		/* chunk = offset / dev->nDataBytesPerChunk + 1; */
-		/* start = offset % dev->nDataBytesPerChunk; */
 		yaffs_AddrToChunk(dev, offset, &chunk, &start);
 
 		if (chunk * dev->nDataBytesPerChunk + start != offset ||
@@ -4913,7 +5178,7 @@ int yaffs_WriteDataToFile(yaffs_Object *in, const __u8 *buffer, loff_t offset,
 			   TENDSTR),
 			   (int)offset, chunk, start));
 		}
-		chunk++;
+		chunk++; /* File pos to chunk in file offset */
 
 		/* OK now check for the curveball where the start and end are in
 		 * the same chunk.
@@ -4959,19 +5224,17 @@ int yaffs_WriteDataToFile(yaffs_Object *in, const __u8 *buffer, loff_t offset,
 				cache = yaffs_FindChunkCache(in, chunk);
 
 				if (!cache
-				    && yaffs_CheckSpaceForAllocation(in->
-								     myDev)) {
-					cache = yaffs_GrabChunkCache(in->myDev);
+				    && yaffs_CheckSpaceForAllocation(dev, 1)) {
+					cache = yaffs_GrabChunkCache(dev);
 					cache->object = in;
 					cache->chunkId = chunk;
 					cache->dirty = 0;
 					cache->locked = 0;
 					yaffs_ReadChunkDataFromObject(in, chunk,
-								      cache->
-								      data);
+								      cache->data);
 				} else if (cache &&
 					!cache->dirty &&
-					!yaffs_CheckSpaceForAllocation(in->myDev)) {
+					!yaffs_CheckSpaceForAllocation(dev, 1)) {
 					/* Drop the cache if it was a read cache item and
 					 * no space check has been made for it.
 					 */
@@ -5062,6 +5325,14 @@ int yaffs_WriteDataToFile(yaffs_Object *in, const __u8 *buffer, loff_t offset,
 	return nDone;
 }
 
+int yaffs_WriteDataToFile(yaffs_Object *in, const __u8 *buffer, loff_t offset,
+			int nBytes, int writeThrough)
+{
+	yaffs_HandleHole(in,offset);
+	return yaffs_DoWriteDataToFile(in,buffer,offset,nBytes,writeThrough);
+}
+
+
 
 /* ---------------------- File resizing stuff ------------------ */
 
@@ -5106,58 +5377,146 @@ static void yaffs_PruneResizedChunks(yaffs_Object *in, int newSize)
 
 }
 
-int yaffs_ResizeFile(yaffs_Object *in, loff_t newSize)
-{
 
-	int oldFileSize = in->variant.fileVariant.fileSize;
-	__u32 newSizeOfPartialChunk;
+static void yaffs_ResizeDown( yaffs_Object *obj, loff_t newSize)
+{
 	int newFullChunks;
-
-	yaffs_Device *dev = in->myDev;
+	__u32 newSizeOfPartialChunk;
+	yaffs_Device *dev = obj->myDev;
 
 	yaffs_AddrToChunk(dev, newSize, &newFullChunks, &newSizeOfPartialChunk);
 
-	yaffs_FlushFilesChunkCache(in);
-	yaffs_InvalidateWholeChunkCache(in);
+	yaffs_PruneResizedChunks(obj, newSize);
 
-	yaffs_CheckGarbageCollection(dev);
+	if (newSizeOfPartialChunk != 0) {
+		int lastChunk = 1 + newFullChunks;
+		__u8 *localBuffer = yaffs_GetTempBuffer(dev, __LINE__);
 
-	if (in->variantType != YAFFS_OBJECT_TYPE_FILE)
-		return YAFFS_FAIL;
+		/* Got to read and rewrite the last chunk with its new size and zero pad */
+		yaffs_ReadChunkDataFromObject(obj, lastChunk, localBuffer);
+		memset(localBuffer + newSizeOfPartialChunk, 0,
+			dev->nDataBytesPerChunk - newSizeOfPartialChunk);
 
-	if (newSize == oldFileSize)
-		return YAFFS_OK;
+		yaffs_WriteChunkDataToObject(obj, lastChunk, localBuffer,
+					     newSizeOfPartialChunk, 1);
+
+		yaffs_ReleaseTempBuffer(dev, localBuffer, __LINE__);
+	}
+
+	obj->variant.fileVariant.fileSize = newSize;
+
+	yaffs_PruneFileStructure(dev, &obj->variant.fileVariant);
+}
+
+
+static int yaffs_HandleHole(yaffs_Object *obj, loff_t newSize)
+{
+	/* if newsSize > oldFileSize.
+	 * We're going to be writing a hole.
+	 * If the hole is small then write zeros otherwise write a start of hole marker.
+	 */
+		
 
-	if (newSize < oldFileSize) {
+	loff_t oldFileSize;
+	int increase;
+	int smallHole   ;
+	int result = YAFFS_OK;
+	yaffs_Device *dev = NULL;
 
-		yaffs_PruneResizedChunks(in, newSize);
+	__u8 *localBuffer = NULL;
+	
+	int smallIncreaseOk = 0;
+	
+	if(!obj)
+		return YAFFS_FAIL;
 
-		if (newSizeOfPartialChunk != 0) {
-			int lastChunk = 1 + newFullChunks;
+	if(obj->variantType != YAFFS_OBJECT_TYPE_FILE)
+		return YAFFS_FAIL;
+	
+	dev = obj->myDev;
+	
+	/* Bail out if not yaffs2 mode */
+	if(!dev->param.isYaffs2)
+		return YAFFS_OK;
 
-			__u8 *localBuffer = yaffs_GetTempBuffer(dev, __LINE__);
+	oldFileSize = obj->variant.fileVariant.fileSize;
 
-			/* Got to read and rewrite the last chunk with its new size and zero pad */
-			yaffs_ReadChunkDataFromObject(in, lastChunk,
-						      localBuffer);
+	if (newSize <= oldFileSize)
+		return YAFFS_OK;
 
-			memset(localBuffer + newSizeOfPartialChunk, 0,
-			       dev->nDataBytesPerChunk - newSizeOfPartialChunk);
+	increase = newSize - oldFileSize;
 
-			yaffs_WriteChunkDataToObject(in, lastChunk, localBuffer,
-						     newSizeOfPartialChunk, 1);
+	if(increase < YAFFS_SMALL_HOLE_THRESHOLD * dev->nDataBytesPerChunk &&
+		yaffs_CheckSpaceForAllocation(dev, YAFFS_SMALL_HOLE_THRESHOLD + 1))
+		smallHole = 1;
+	else
+		smallHole = 0;
 
-			yaffs_ReleaseTempBuffer(dev, localBuffer, __LINE__);
+	if(smallHole)
+		localBuffer= yaffs_GetTempBuffer(dev, __LINE__);
+	
+	if(localBuffer){
+		/* fill hole with zero bytes */
+		int pos = oldFileSize;
+		int thisWrite;
+		int written;
+		memset(localBuffer,0,dev->nDataBytesPerChunk);
+		smallIncreaseOk = 1;
+
+		while(increase > 0 && smallIncreaseOk){
+			thisWrite = increase;
+			if(thisWrite > dev->nDataBytesPerChunk)
+				thisWrite = dev->nDataBytesPerChunk;
+			written = yaffs_DoWriteDataToFile(obj,localBuffer,pos,thisWrite,0);
+			if(written == thisWrite){
+				pos += thisWrite;
+				increase -= thisWrite;
+			} else
+				smallIncreaseOk = 0;
 		}
 
-		in->variant.fileVariant.fileSize = newSize;
+		yaffs_ReleaseTempBuffer(dev,localBuffer,__LINE__);
 
-		yaffs_PruneFileStructure(dev, &in->variant.fileVariant);
-	} else {
-		/* newsSize > oldFileSize */
-		in->variant.fileVariant.fileSize = newSize;
+		/* If we were out of space then reverse any chunks we've added */		
+		if(!smallIncreaseOk)
+			yaffs_ResizeDown(obj, oldFileSize);
 	}
+	
+	if (!smallIncreaseOk &&
+		obj->parent &&
+		obj->parent->objectId != YAFFS_OBJECTID_UNLINKED &&
+		obj->parent->objectId != YAFFS_OBJECTID_DELETED){
+		/* Write a hole start header with the old file size */
+		yaffs_UpdateObjectHeader(obj, NULL, 0, 1, 0, NULL);
+	}
+
+	return result;
 
+}
+
+int yaffs_ResizeFile(yaffs_Object *in, loff_t newSize)
+{
+	yaffs_Device *dev = in->myDev;
+	int oldFileSize = in->variant.fileVariant.fileSize;
+
+	yaffs_FlushFilesChunkCache(in);
+	yaffs_InvalidateWholeChunkCache(in);
+
+	yaffs_CheckGarbageCollection(dev,0);
+
+	if (in->variantType != YAFFS_OBJECT_TYPE_FILE)
+		return YAFFS_FAIL;
+
+	if (newSize == oldFileSize)
+		return YAFFS_OK;
+		
+	if(newSize > oldFileSize){
+		yaffs_HandleHole(in,newSize);
+		in->variant.fileVariant.fileSize = newSize;
+	} else {
+		/* newSize < oldFileSize */ 
+		yaffs_ResizeDown(in, newSize);
+	} 
 
 	/* Write a new object header to reflect the resize.
 	 * show we've shrunk the file, if need be
@@ -5168,8 +5527,8 @@ int yaffs_ResizeFile(yaffs_Object *in, loff_t newSize)
 	    !in->isShadowed &&
 	    in->parent->objectId != YAFFS_OBJECTID_UNLINKED &&
 	    in->parent->objectId != YAFFS_OBJECTID_DELETED)
-		yaffs_UpdateObjectHeader(in, NULL, 0,
-					 (newSize < oldFileSize) ? 1 : 0, 0);
+		yaffs_UpdateObjectHeader(in, NULL, 0, 0, 0, NULL);
+
 
 	return YAFFS_OK;
 }
@@ -5212,7 +5571,7 @@ int yaffs_FlushFile(yaffs_Object *in, int updateTime, int dataSync)
 #endif
 			}
 
-			retVal = (yaffs_UpdateObjectHeader(in, NULL, 0, 0, 0) >=
+			retVal = (yaffs_UpdateObjectHeader(in, NULL, 0, 0, 0, NULL) >=
 				0) ? YAFFS_OK : YAFFS_FAIL;
 		}
 	} else {
@@ -5253,6 +5612,7 @@ static int yaffs_UnlinkFileIfNeeded(yaffs_Object *in)
 
 	int retVal;
 	int immediateDeletion = 0;
+	yaffs_Device *dev = in->myDev;
 
 	if (!in->myInode)
 		immediateDeletion = 1;
@@ -5266,7 +5626,7 @@ static int yaffs_UnlinkFileIfNeeded(yaffs_Object *in)
 		   in->objectId));
 		in->deleted = 1;
 		in->myDev->nDeletedFiles++;
-		if (1 || in->myDev->param.isYaffs2)
+		if (dev->param.disableSoftDelete || dev->param.isYaffs2)
 			yaffs_ResizeFile(in, 0);
 		yaffs_SoftDeleteFile(in);
 	} else {
@@ -5282,9 +5642,11 @@ static int yaffs_UnlinkFileIfNeeded(yaffs_Object *in)
 int yaffs_DeleteFile(yaffs_Object *in)
 {
 	int retVal = YAFFS_OK;
-	int deleted = in->deleted;
+	int deleted; /* Need to cache value on stack if in is freed */
+	yaffs_Device *dev = in->myDev;
 
-	yaffs_ResizeFile(in, 0);
+	if (dev->param.disableSoftDelete || dev->param.isYaffs2)
+		yaffs_ResizeFile(in, 0);
 
 	if (in->nDataChunks > 0) {
 		/* Use soft deletion if there is data in the file.
@@ -5293,6 +5655,8 @@ int yaffs_DeleteFile(yaffs_Object *in)
 		if (!in->unlinked)
 			retVal = yaffs_UnlinkFileIfNeeded(in);
 
+		deleted = in->deleted;
+
 		if (retVal == YAFFS_OK && in->unlinked && !in->deleted) {
 			in->deleted = 1;
 			deleted = 1;
@@ -5351,6 +5715,10 @@ int retVal = -1;
 		retVal = yaffs_DeleteFile(obj);
 		break;
 	case YAFFS_OBJECT_TYPE_DIRECTORY:
+		if(!ylist_empty(&obj->variant.directoryVariant.dirty)){
+			T(YAFFS_TRACE_BACKGROUND, (TSTR("Remove object %d from dirty directories" TENDSTR),obj->objectId));
+			ylist_del_init(&obj->variant.directoryVariant.dirty);
+		}
 		return yaffs_DeleteDirectory(obj);
 		break;
 	case YAFFS_OBJECT_TYPE_SYMLINK:
@@ -5425,6 +5793,7 @@ static int yaffs_UnlinkWorker(yaffs_Object *obj)
 			return yaffs_DeleteFile(obj);
 			break;
 		case YAFFS_OBJECT_TYPE_DIRECTORY:
+			ylist_del_init(&obj->variant.directoryVariant.dirty);
 			return yaffs_DeleteDirectory(obj);
 			break;
 		case YAFFS_OBJECT_TYPE_SYMLINK:
@@ -5742,8 +6111,8 @@ static int yaffs_Scan(yaffs_Device *dev)
 	dev->sequenceNumber = YAFFS_LOWEST_SEQUENCE_NUMBER;
 
 	/* Scan all the blocks to determine their state */
+	bi = dev->blockInfo;
 	for (blk = dev->internalStartBlock; blk <= dev->internalEndBlock; blk++) {
-		bi = yaffs_GetBlockInfo(dev, blk);
 		yaffs_ClearChunkBits(dev, blk);
 		bi->pagesInUse = 0;
 		bi->softDeletions = 0;
@@ -5769,6 +6138,7 @@ static int yaffs_Scan(yaffs_Device *dev)
 			dev->nErasedBlocks++;
 			dev->nFreeChunks += dev->param.nChunksPerBlock;
 		}
+		bi++;
 	}
 
 	startIterator = dev->internalStartBlock;
@@ -6126,7 +6496,7 @@ static int yaffs_Scan(yaffs_Device *dev)
 			obj = yaffs_FindObjectByNumber(dev, fixer->objectId);
 
 			if (obj)
-				yaffs_UpdateObjectHeader(obj, NULL, 1, 0, 0);
+				yaffs_UpdateObjectHeader(obj, NULL, 1, 0, 0, NULL);
 
 			YFREE(fixer);
 		}
@@ -6266,8 +6636,8 @@ static int yaffs_ScanBackwards(yaffs_Device *dev)
 	chunkData = yaffs_GetTempBuffer(dev, __LINE__);
 
 	/* Scan all the blocks to determine their state */
+	bi = dev->blockInfo;
 	for (blk = dev->internalStartBlock; blk <= dev->internalEndBlock; blk++) {
-		bi = yaffs_GetBlockInfo(dev, blk);
 		yaffs_ClearChunkBits(dev, blk);
 		bi->pagesInUse = 0;
 		bi->softDeletions = 0;
@@ -6320,6 +6690,7 @@ static int yaffs_ScanBackwards(yaffs_Device *dev)
 
 			}
 		}
+		bi++;
 	}
 
 	T(YAFFS_TRACE_SCAN,
@@ -6433,7 +6804,7 @@ static int yaffs_ScanBackwards(yaffs_Device *dev)
 							 * the current allocation block.
 							 */
 
-							 T(YAFFS_TRACE_ALWAYS,
+							 T(YAFFS_TRACE_SCAN,
 							 (TSTR("Partially written block %d detected" TENDSTR),
 							 blk));
 						}
@@ -6472,35 +6843,26 @@ static int yaffs_ScanBackwards(yaffs_Device *dev)
 
 				if (in &&
 				    in->variantType == YAFFS_OBJECT_TYPE_FILE
-				    && chunkBase <
-				    in->variant.fileVariant.shrinkSize) {
+				    && chunkBase < in->variant.fileVariant.shrinkSize) {
 					/* This has not been invalidated by a resize */
-					if (!yaffs_PutChunkIntoFile(in, tags.chunkId,
-							       chunk, -1)) {
+					if (!yaffs_PutChunkIntoFile(in, tags.chunkId, chunk, -1)) {
 						alloc_failed = 1;
 					}
 
 					/* File size is calculated by looking at the data chunks if we have not
 					 * seen an object header yet. Stop this practice once we find an object header.
 					 */
-					endpos =
-					    (tags.chunkId -
-					     1) * dev->nDataBytesPerChunk +
-					    tags.byteCount;
+					endpos = chunkBase + tags.byteCount;
 
 					if (!in->valid &&	/* have not got an object header yet */
-					    in->variant.fileVariant.
-					    scannedFileSize < endpos) {
-						in->variant.fileVariant.
-						    scannedFileSize = endpos;
-						in->variant.fileVariant.
-						    fileSize =
-						    in->variant.fileVariant.
-						    scannedFileSize;
+					    in->variant.fileVariant.scannedFileSize < endpos) {
+						in->variant.fileVariant.scannedFileSize = endpos;
+						in->variant.fileVariant.fileSize = endpos;
 					}
 
 				} else if (in) {
-					/* This chunk has been invalidated by a resize, so delete */
+					/* This chunk has been invalidated by a resize, or a past file deletion
+					 * so delete the chunk*/
 					yaffs_DeleteChunk(dev, chunk, 1, __LINE__);
 
 				}
@@ -6517,9 +6879,9 @@ static int yaffs_ScanBackwards(yaffs_Device *dev)
 				in = NULL;
 
 				if (tags.extraHeaderInfoAvailable) {
-					in = yaffs_FindOrCreateObjectByNumber
-					    (dev, tags.objectId,
-					     tags.extraObjectType);
+					in = yaffs_FindOrCreateObjectByNumber(dev,
+						tags.objectId,
+						tags.extraObjectType);
 					if (!in)
 						alloc_failed = 1;
 				}
@@ -6601,13 +6963,8 @@ static int yaffs_ScanBackwards(yaffs_Device *dev)
 							isShrink = 1;
 						}
 
-						if (isShrink &&
-						    in->variant.fileVariant.
-						    shrinkSize > thisSize) {
-							in->variant.fileVariant.
-							    shrinkSize =
-							    thisSize;
-						}
+						if (isShrink && in->variant.fileVariant.shrinkSize > thisSize)
+							in->variant.fileVariant.shrinkSize = thisSize;
 
 						if (isShrink)
 							bi->hasShrinkHeader = 1;
@@ -6780,14 +7137,12 @@ static int yaffs_ScanBackwards(yaffs_Device *dev)
 							 * than its current data extents.
 							 */
 							in->variant.fileVariant.fileSize = fileSize;
-							in->variant.fileVariant.scannedFileSize =
-							    in->variant.fileVariant.fileSize;
+							in->variant.fileVariant.scannedFileSize = fileSize;
 						}
 
-						if (isShrink &&
-						    in->variant.fileVariant.shrinkSize > fileSize) {
+						if (in->variant.fileVariant.shrinkSize > fileSize)
 							in->variant.fileVariant.shrinkSize = fileSize;
-						}
+				
 
 						break;
 					case YAFFS_OBJECT_TYPE_HARDLINK:
@@ -6949,17 +7304,57 @@ static void yaffs_VerifyDirectory(yaffs_Object *directory)
  *   create dir/a : update dir's mtime/ctime
  *   rm dir/a:   update dir's mtime/ctime
  *   modify dir/a: don't update dir's mtimme/ctime
+ *
+ * This can be handled immediately or defered. Defering helps reduce the number
+ * of updates when many files in a directory are changed within a brief period.
+ *
+ * If the directory updating is defered then yaffs_UpdateDirtyDirecories must be
+ * called periodically.
  */
  
 static void yaffs_UpdateParent(yaffs_Object *obj)
 {
+	yaffs_Device *dev;
 	if(!obj)
 		return;
 
+	dev = obj->myDev;
 	obj->dirty = 1;
 	obj->yst_mtime = obj->yst_ctime = Y_CURRENT_TIME;
+	if(dev->param.deferDirectoryUpdate){
+		struct ylist_head *link = &obj->variant.directoryVariant.dirty; 
+	
+		if(ylist_empty(link)){
+			ylist_add(link,&dev->dirtyDirectories);
+			T(YAFFS_TRACE_BACKGROUND, (TSTR("Added object %d to dirty directories" TENDSTR),obj->objectId));
+		}
 
-	yaffs_UpdateObjectHeader(obj,NULL,0,0,0);
+	} else
+		yaffs_UpdateObjectHeader(obj, NULL, 0, 0, 0, NULL);
+}
+
+void yaffs_UpdateDirtyDirectories(yaffs_Device *dev)
+{
+	struct ylist_head *link;
+	yaffs_Object *obj;
+	yaffs_DirectoryStructure *dS;
+	yaffs_ObjectVariant *oV;
+
+	T(YAFFS_TRACE_BACKGROUND, (TSTR("Update dirty directories" TENDSTR)));
+
+	while(!ylist_empty(&dev->dirtyDirectories)){
+		link = dev->dirtyDirectories.next;
+		ylist_del_init(link);
+		
+		dS=ylist_entry(link,yaffs_DirectoryStructure,dirty);
+		oV = ylist_entry(dS,yaffs_ObjectVariant,directoryVariant);
+		obj = ylist_entry(oV,yaffs_Object,variant);
+
+		T(YAFFS_TRACE_BACKGROUND, (TSTR("Update directory %d" TENDSTR), obj->objectId));
+
+		if(obj->dirty)
+			yaffs_UpdateObjectHeader(obj, NULL, 0, 0, 0, NULL);
+	}
 }
 
 static void yaffs_RemoveObjectFromDirectory(yaffs_Object *obj)
@@ -7289,7 +7684,7 @@ int yaffs_SetAttributes(yaffs_Object *obj, struct iattr *attr)
 	if (valid & ATTR_SIZE)
 		yaffs_ResizeFile(obj, attr->ia_size);
 
-	yaffs_UpdateObjectHeader(obj, NULL, 1, 0, 0);
+	yaffs_UpdateObjectHeader(obj, NULL, 1, 0, 0, NULL);
 
 	return YAFFS_OK;
 
@@ -7322,6 +7717,104 @@ int yaffs_GetAttributes(yaffs_Object *obj, struct iattr *attr)
 
 #endif
 
+
+static int yaffs_DoXMod(yaffs_Object *obj, int set, const char *name, const void *value, int size, int flags)
+{
+	yaffs_XAttrMod xmod;
+
+	int result;
+
+	xmod.set = set;
+	xmod.name = name;
+	xmod.data = value;
+	xmod.size =  size;
+	xmod.flags = flags;
+	xmod.result = -ENOSPC;
+
+	result = yaffs_UpdateObjectHeader(obj, NULL, 0, 0, 0, &xmod);
+
+	if(result > 0)
+		return xmod.result;
+	else
+		return -ENOSPC;
+}
+
+static int yaffs_ApplyXMod(yaffs_Device *dev, char *buffer, yaffs_XAttrMod *xmod)
+{
+	int retval = 0;
+	int x_offs = sizeof(yaffs_ObjectHeader);
+	int x_size = dev->nDataBytesPerChunk - sizeof(yaffs_ObjectHeader);
+
+	char * x_buffer = buffer + x_offs;
+
+	if(xmod->set)
+		retval = nval_set(x_buffer, x_size, xmod->name, xmod->data, xmod->size, xmod->flags);
+	else
+		retval = nval_del(x_buffer, x_size, xmod->name);
+
+	xmod->result = retval;
+
+	return retval;
+}
+
+static int yaffs_DoXFetch(yaffs_Object *obj, const char *name, void *value, int size)
+{
+	char *buffer = NULL;
+	int result;
+	yaffs_ExtendedTags tags;
+	yaffs_Device *dev = obj->myDev;
+	int x_offs = sizeof(yaffs_ObjectHeader);
+	int x_size = dev->nDataBytesPerChunk - sizeof(yaffs_ObjectHeader);
+
+	__u8 * x_buffer;
+
+	int retval = 0;
+
+	if(obj->hdrChunk < 1)
+		return -ENOENT;
+
+	buffer = yaffs_GetTempBuffer(dev, __LINE__);
+	if(!buffer)
+		return -ENOMEM;
+
+	result = yaffs_ReadChunkWithTagsFromNAND(dev,obj->hdrChunk, buffer, &tags);
+
+	if(result != YAFFS_OK)
+		retval = -ENOENT;
+	else{
+		x_buffer =  buffer + x_offs;
+
+		if(name)
+			retval = nval_get(x_buffer, x_size, name, value, size);
+		else
+			retval = nval_list(x_buffer, x_size, value,size);
+	}
+	yaffs_ReleaseTempBuffer(dev,buffer,__LINE__);
+	return retval;
+}
+
+int yaffs_SetXAttribute(yaffs_Object *obj, const char *name, const void * value, int size, int flags)
+{
+	return yaffs_DoXMod(obj, 1, name, value, size, flags);
+}
+
+int yaffs_RemoveXAttribute(yaffs_Object *obj, const char *name)
+{
+	return yaffs_DoXMod(obj, 0, name, NULL, 0, 0);
+}
+
+int yaffs_GetXAttribute(yaffs_Object *obj, const char *name, void *value, int size)
+{
+	return yaffs_DoXFetch(obj, name, value, size);
+}
+
+int yaffs_ListXAttributes(yaffs_Object *obj, char *buffer, int size)
+{
+	return yaffs_DoXFetch(obj, NULL, buffer,size);
+}
+
+
+
 #if 0
 int yaffs_DumpObject(yaffs_Object *obj)
 {
@@ -7425,7 +7918,7 @@ int yaffs_GutsInitialise(yaffs_Device *dev)
 	dev->chunkOffset = 0;
 	dev->nFreeChunks = 0;
 
-	dev->gcBlock = -1;
+	dev->gcBlock = 0;
 
 	if (dev->param.startBlock == 0) {
 		dev->internalStartBlock = dev->param.startBlock + 1;
@@ -7554,9 +8047,11 @@ int yaffs_GutsInitialise(yaffs_Device *dev)
 	/* OK, we've finished verifying the device, lets continue with initialisation */
 
 	/* More device initialisation */
-	dev->garbageCollections = 0;
-	dev->passiveGarbageCollections = 0;
-	dev->currentDirtyChecker = 0;
+	dev->allGCs = 0;
+	dev->passiveGCs = 0;
+	dev->oldestDirtyGCs = 0;
+	dev->backgroundGCs = 0;
+	dev->gcBlockFinder = 0;
 	dev->bufferedBlock = -1;
 	dev->doingBufferedBlockRewrite = 0;
 	dev->nDeletedFiles = 0;
@@ -7568,8 +8063,11 @@ int yaffs_GutsInitialise(yaffs_Device *dev)
 	dev->tagsEccUnfixed = 0;
 	dev->nErasureFailures = 0;
 	dev->nErasedBlocks = 0;
-	dev->isDoingGC = 0;
+	dev->gcDisable= 0;
 	dev->hasPendingPrioritisedGCs = 1; /* Assume the worst for now, will get fixed on first GC */
+	YINIT_LIST_HEAD(&dev->dirtyDirectories);
+	dev->oldestDirtySequence = 0;
+	dev->oldestDirtyBlock = 0;
 
 	/* Initialise temporary buffers and caches. */
 	if (!yaffs_InitialiseTempBuffers(dev))
@@ -7652,7 +8150,6 @@ int yaffs_GutsInitialise(yaffs_Device *dev)
 				dev->nDeletedFiles = 0;
 				dev->nUnlinkedFiles = 0;
 				dev->nBackgroundDeletions = 0;
-				dev->oldestDirtySequence = 0;
 
 				if (!init_failed && !yaffs_InitialiseBlocks(dev))
 					init_failed = 1;
@@ -7741,15 +8238,13 @@ void yaffs_Deinitialise(yaffs_Device *dev)
 
 static int yaffs_CountFreeChunks(yaffs_Device *dev)
 {
-	int nFree;
+	int nFree=0;
 	int b;
 
 	yaffs_BlockInfo *blk;
 
-	for (nFree = 0, b = dev->internalStartBlock; b <= dev->internalEndBlock;
-			b++) {
-		blk = yaffs_GetBlockInfo(dev, b);
-
+	blk = dev->blockInfo;
+	for (b = dev->internalStartBlock; b <= dev->internalEndBlock; b++) {
 		switch (blk->blockState) {
 		case YAFFS_BLOCK_STATE_EMPTY:
 		case YAFFS_BLOCK_STATE_ALLOCATING:
@@ -7762,6 +8257,7 @@ static int yaffs_CountFreeChunks(yaffs_Device *dev)
 		default:
 			break;
 		}
+		blk++;
 	}
 
 	return nFree;