X-Git-Url: http://www.aleph1.co.uk/gitweb/?a=blobdiff_plain;f=yaffs_guts.c;h=b042a9a7c61dbaf9a0f659e503d34c60525a0583;hb=a1d28cf77fe06fe98cea4c4e80cc1cab94ea6736;hp=4c7e81af75ef9b1c136ec0a4b464cde7272c3ba5;hpb=3f107ebf545c27322a15a458198a3cd5dbc876f3;p=yaffs%2F.git

diff --git a/yaffs_guts.c b/yaffs_guts.c
index 4c7e81a..b042a9a 100644
--- a/yaffs_guts.c
+++ b/yaffs_guts.c
@@ -20,11 +20,8 @@
 #include "yaffs_guts.h"
 
 
-#if 0
-#define T(x) printf x
-#else
-#define T(x)
-#endif
+#define YAFFS_GARBAGE_COLLECT_LOW_WATER 2
+
 
 // External functions for ECC on data
 void nand_calculate_ecc (const u_char *dat, u_char *ecc_code);
@@ -34,7 +31,7 @@ int nand_correct_data (u_char *dat, u_char *read_ecc, u_char *calc_ecc);
 // countBits is a quick way of counting the number of bits in a byte.
 // ie. countBits[n] holds the number of 1 bits in a byte with the value n.
 
-static const char yaffs_countBits[256] =
+static const char yaffs_countBitsTable[256] =
 {
 0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4,
 1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,
@@ -54,12 +51,12 @@ static const char yaffs_countBits[256] =
 4,5,5,6,5,6,6,7,5,6,6,7,6,7,7,8
 };
 
-
-
-// Device info
-//static yaffs_Device *yaffs_device;
-//yaffs_Object *yaffs_rootDir;
-//yaffs_Object *yaffs_lostNFound;
+static int yaffs_CountBits(__u8 x)
+{
+	int retVal;
+	retVal = yaffs_countBitsTable[x];
+	return retVal;
+}
 
 
 
@@ -71,13 +68,36 @@ static int yaffs_PutChunkIntoFile(yaffs_Object *in,int chunkInInode, int chunkIn
 
 static yaffs_Object *yaffs_CreateNewObject(yaffs_Device *dev,int number,yaffs_ObjectType type);
 static void yaffs_AddObjectToDirectory(yaffs_Object *directory, yaffs_Object *obj);
-static int yaffs_UpdateObjectHeader(yaffs_Object *in,const char *name);
+static int yaffs_UpdateObjectHeader(yaffs_Object *in,const char *name, int force);
 static void yaffs_DeleteChunk(yaffs_Device *dev,int chunkId);
 static void yaffs_RemoveObjectFromDirectory(yaffs_Object *obj);
 static int yaffs_CheckStructures(void);
+static void 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);
+
+// Robustification
+static void yaffs_RetireBlock(yaffs_Device *dev,int blockInNAND);
+static void yaffs_HandleReadDataError(yaffs_Device *dev,int chunkInNAND);
+static void yaffs_HandleWriteChunkError(yaffs_Device *dev,int chunkInNAND);
+static void yaffs_HandleWriteChunkOk(yaffs_Device *dev,int chunkInNAND,const __u8 *data, const yaffs_Spare *spare);
+static void yaffs_HandleUpdateChunk(yaffs_Device *dev,int chunkInNAND, const yaffs_Spare *spare);
+
+static int  yaffs_CheckChunkErased(struct yaffs_DeviceStruct *dev,int chunkInNAND);
+
+static int yaffs_UnlinkWorker(yaffs_Object *obj);
+
+
+static int yaffs_VerifyCompare(const __u8 *d0, const __u8 * d1, const yaffs_Spare *s0, const yaffs_Spare *s1);
+
+
 
 loff_t yaffs_GetFileSize(yaffs_Object *obj);
 
+static int yaffs_ReadChunkTagsFromNAND(yaffs_Device *dev,int chunkInNAND, yaffs_Tags *tags, int *chunkDeleted);
+static int yaffs_TagsMatch(const yaffs_Tags *tags, int objectId, int chunkInObject, int chunkDeleted);
+
 
 static int yaffs_AllocateChunk(yaffs_Device *dev,int useReserve);
 
@@ -87,7 +107,25 @@ static int yaffs_CheckFileSanity(yaffs_Object *in);
 #define yaffs_CheckFileSanity(in)
 #endif
 
-static int __inline__ yaffs_HashFunction(int n)
+#ifdef CONFIG_YAFFS_SHORT_OP_CACHE
+static void yaffs_InvalidateChunkCache(yaffs_Object *in);
+#define	yaffs_INVALIDATECHUNKCACHE(in) yaffs_InvalidateChunkCache(in)
+#else
+#define yaffs_INVALIDATECHUNKCACHE(in)
+#endif
+
+
+static  __inline__ yaffs_BlockInfo* yaffs_GetBlockInfo(yaffs_Device *dev, int blk)
+{
+	if(blk < dev->startBlock || blk > dev->endBlock)
+	{
+		YBUG();
+	}
+	return &dev->blockInfo[blk - dev->startBlock];
+}
+
+
+static  __inline__ int yaffs_HashFunction(int n)
 {
 	return (n % YAFFS_NOBJECT_BUCKETS);
 }
@@ -106,14 +144,19 @@ yaffs_Object *yaffs_LostNFound(yaffs_Device *dev)
 
 static int yaffs_WriteChunkToNAND(struct yaffs_DeviceStruct *dev,int chunkInNAND, const __u8 *data, yaffs_Spare *spare)
 {
+	dev->nPageWrites++;
 	return dev->writeChunkToNAND(dev,chunkInNAND,data,spare);
 }
 
-int yaffs_ReadChunkFromNAND(struct yaffs_DeviceStruct *dev,int chunkInNAND, __u8 *data, yaffs_Spare *spare)
+
+int yaffs_ReadChunkFromNAND(struct yaffs_DeviceStruct *dev,int chunkInNAND, __u8 *data, yaffs_Spare *spare,int doErrorCorrection)
 {
 	int retVal;
 	__u8 calcEcc[3];
 	yaffs_Spare localSpare;
+	int eccResult1,eccResult2;
+	
+	dev->nPageReads++;
 	
 	if(!spare && data)
 	{
@@ -123,30 +166,51 @@ int yaffs_ReadChunkFromNAND(struct yaffs_DeviceStruct *dev,int chunkInNAND, __u8
 	}
 	
 	retVal  = dev->readChunkFromNAND(dev,chunkInNAND,data,spare);
-	if(data)
+	if(data && doErrorCorrection)
 	{
 		// Do ECC correction
 		//Todo handle any errors
 		 nand_calculate_ecc(data,calcEcc);
-		 nand_correct_data (data,spare->ecc1, calcEcc);
+		 eccResult1 = nand_correct_data (data,spare->ecc1, calcEcc);
 		 nand_calculate_ecc(&data[256],calcEcc);
-		 nand_correct_data (&data[256],spare->ecc2, calcEcc);
+		 eccResult2 = nand_correct_data (&data[256],spare->ecc2, calcEcc);
+		 
+		 if(eccResult1>0)
+		 {
+		 	T((TSTR("**>>ecc error fix performed on chunk %d:0" TENDSTR),chunkInNAND));
+		 }
+		 else if(eccResult1<0)
+		 {
+		 	T((TSTR("**>>ecc error unfixed on chunk %d:0" TENDSTR),chunkInNAND));
+		 }
+		 
+		 if(eccResult2>0)
+		 {
+		 	T((TSTR("**>>ecc error fix performed on chunk %d:1" TENDSTR),chunkInNAND));
+		 }
+		 else if(eccResult2<0)
+		 {
+		 	T((TSTR("**>>ecc error unfixed on chunk %d:1" TENDSTR),chunkInNAND));
+		 }
+		 
+		 if(eccResult1 || eccResult2)
+		 {
+		 	// Hoosterman, we had a data problem on this page
+			yaffs_HandleReadDataError(dev,chunkInNAND);
+		 }
 	}
 	return retVal;
 }
 
-#ifdef YAFFS_PARANOID
 
 static int yaffs_CheckChunkErased(struct yaffs_DeviceStruct *dev,int chunkInNAND)
 {
+
 	static int init = 0;
 	static __u8 cmpbuf[YAFFS_BYTES_PER_CHUNK];
 	static __u8 data[YAFFS_BYTES_PER_CHUNK];
 	static __u8 spare[16];
 	
-	int retVal;
-	
-	retVal  = YAFFS_OK;
 	
 	dev->readChunkFromNAND(dev,chunkInNAND,data,(yaffs_Spare *)spare);
 	
@@ -158,18 +222,19 @@ static int yaffs_CheckChunkErased(struct yaffs_DeviceStruct *dev,int chunkInNAND
 		init = 1;
 	}
 	
-	if(memcmp(cmpbuf,data,YAFFS_BYTES_PER_CHUNK)) retVal = YAFFS_FAIL;
-	if(memcmp(cmpbuf,spare,16)) retVal = YAFFS_FAIL;
+	if(memcmp(cmpbuf,data,YAFFS_BYTES_PER_CHUNK)) return  YAFFS_FAIL;
+	if(memcmp(cmpbuf,spare,16)) return YAFFS_FAIL;
+
 	
-	return retVal;
+	return YAFFS_OK;
 	
 }
 
-#endif
 
 
 int yaffs_EraseBlockInNAND(struct yaffs_DeviceStruct *dev,int blockInNAND)
 {
+	dev->nBlockErasures++;
 	return dev->eraseBlockInNAND(dev,blockInNAND);
 }
 
@@ -182,7 +247,8 @@ static int yaffs_WriteNewChunkToNAND(struct yaffs_DeviceStruct *dev, const __u8
 {
 	int chunk;
 	
-	int writeOk = 0;
+	int writeOk = 1;
+	int attempts = 0;
 	
 	unsigned char rbData[YAFFS_BYTES_PER_CHUNK];
 	yaffs_Spare rbSpare;
@@ -192,44 +258,167 @@ static int yaffs_WriteNewChunkToNAND(struct yaffs_DeviceStruct *dev, const __u8
 	
 		if(chunk >= 0)
 		{
-			writeOk =  yaffs_WriteChunkToNAND(dev,chunk,data,spare);
+
+			// First check this chunk is erased...
+#ifndef CONFIG_YAFFS_DISABLE_CHUNK_ERASED_CHECK
+			writeOk = yaffs_CheckChunkErased(dev,chunk);
+#endif		
+			if(!writeOk)
+			{
+				T((TSTR("**>> yaffs chunk %d was not erased" TENDSTR),chunk));
+			}
+			else
+			{
+				writeOk =  yaffs_WriteChunkToNAND(dev,chunk,data,spare);
+			}
+			attempts++;
 			if(writeOk)
 			{
 				// Readback & verify
 				// If verify fails, then delete this chunk and try again
 				// To verify we compare everything except the block and 
 				// page status bytes.
-				yaffs_ReadChunkFromNAND(dev,chunk,rbData,&rbSpare);
+				// NB We check a raw read without ECC correction applied
+				yaffs_ReadChunkFromNAND(dev,chunk,rbData,&rbSpare,0);
 				
-				if(memcmp(data,rbData,YAFFS_BYTES_PER_CHUNK) != 0 ||
-					spare->tagByte0 != rbSpare.tagByte0 ||
-					spare->tagByte1 != rbSpare.tagByte1 ||
-					spare->tagByte2 != rbSpare.tagByte2 ||
-					spare->tagByte3 != rbSpare.tagByte3 ||
-					spare->tagByte4 != rbSpare.tagByte4 ||
-					spare->tagByte5 != rbSpare.tagByte5 ||
-					spare->tagByte6 != rbSpare.tagByte6 ||
-					spare->tagByte7 != rbSpare.tagByte7 ||
-					spare->ecc1[0]  != rbSpare.ecc1[0]  ||
-					spare->ecc1[1]  != rbSpare.ecc1[1]  ||
-					spare->ecc1[2]  != rbSpare.ecc1[2]  ||
-					spare->ecc2[0]  != rbSpare.ecc2[0]  ||
-					spare->ecc2[1]  != rbSpare.ecc2[1]  ||
-					spare->ecc2[2]  != rbSpare.ecc2[2] )
-				{
+#ifndef CONFIG_YAFFS_DISABLE_WRITE_VERIFY
+				if(!yaffs_VerifyCompare(data,rbData,spare,&rbSpare))
+							{
 					// Didn't verify
-					yaffs_DeleteChunk(dev,chunk);
+					T((TSTR("**>> yaffs write verify failed on chunk %d" TENDSTR), chunk));
+
 					writeOk = 0;
-				}					
+				}	
+#endif				
 				
 			}
+			if(writeOk)
+			{
+				// Copy the data into the write buffer.
+				// NB We do this at the end to prevent duplicates in the case of a write error.
+				//Todo
+				yaffs_HandleWriteChunkOk(dev,chunk,data,spare);
+			}
+			else
+			{
+				yaffs_HandleWriteChunkError(dev,chunk);
+			}
 		}
+		
 	} while(chunk >= 0 && ! writeOk);
 	
+	if(attempts > 1)
+	{
+		T((TSTR("**>> yaffs write required %d attempts" TENDSTR),attempts));
+		dev->nRetriedWrites+= (attempts - 1);	
+	}
+	
 	return chunk;
 }
 
+///
+// Functions for robustisizing
+//
+//
+
+static void yaffs_RetireBlock(yaffs_Device *dev,int blockInNAND)
+{
+	// Ding the blockStatus in the first two pages of the block.
+	
+	yaffs_Spare spare;
+
+	memset(&spare, 0xff,sizeof(yaffs_Spare));
+
+	spare.blockStatus = 0;
+	
+	yaffs_WriteChunkToNAND(dev, blockInNAND * YAFFS_CHUNKS_PER_BLOCK, NULL , &spare);
+	yaffs_WriteChunkToNAND(dev, blockInNAND * YAFFS_CHUNKS_PER_BLOCK + 1, NULL , &spare);
+	
+	yaffs_GetBlockInfo(dev,blockInNAND)->blockState = YAFFS_BLOCK_STATE_DEAD;
+	dev->nRetiredBlocks++;
+}
+
+
+
+static int yaffs_RewriteBufferedBlock(yaffs_Device *dev)
+{
+	dev->doingBufferedBlockRewrite = 1;
+	//
+	//	Remove erased chunks
+	//  Rewrite existing chunks to a new block
+	//	Set current write block to the new block
+	
+	dev->doingBufferedBlockRewrite = 0;
+	
+	return 1;
+}
+
+
+static void yaffs_HandleReadDataError(yaffs_Device *dev,int chunkInNAND)
+{
+	int blockInNAND = chunkInNAND/YAFFS_CHUNKS_PER_BLOCK;
+
+	// Mark the block for retirement
+	yaffs_GetBlockInfo(dev,blockInNAND)->needsRetiring = 1;
+	T((TSTR("**>>Block %d marked for retirement" TENDSTR),blockInNAND));
+
+
+	//TODO	
+	// Just do a garbage collection on the affected block then retire the block
+	// NB recursion
+}
+
+
+static void yaffs_CheckWrittenBlock(yaffs_Device *dev,int chunkInNAND)
+{
+}
+
+static void yaffs_HandleWriteChunkOk(yaffs_Device *dev,int chunkInNAND,const __u8 *data, const yaffs_Spare *spare)
+{
+}
+
+static void yaffs_HandleUpdateChunk(yaffs_Device *dev,int chunkInNAND, const yaffs_Spare *spare)
+{
+}
+
+static void yaffs_HandleWriteChunkError(yaffs_Device *dev,int chunkInNAND)
+{
+	int blockInNAND = chunkInNAND/YAFFS_CHUNKS_PER_BLOCK;
+
+	// Mark the block for retirement
+	yaffs_GetBlockInfo(dev,blockInNAND)->needsRetiring = 1;
+	// Delete the chunk
+	yaffs_DeleteChunk(dev,chunkInNAND);
+}
+
+
+
 
+static int yaffs_VerifyCompare(const __u8 *d0, const __u8 * d1, const yaffs_Spare *s0, const yaffs_Spare *s1)
+{
+
+
+	if( memcmp(d0,d1,YAFFS_BYTES_PER_CHUNK) != 0 ||
+		s0->tagByte0 != s1->tagByte0 ||
+		s0->tagByte1 != s1->tagByte1 ||
+		s0->tagByte2 != s1->tagByte2 ||
+		s0->tagByte3 != s1->tagByte3 ||
+		s0->tagByte4 != s1->tagByte4 ||
+		s0->tagByte5 != s1->tagByte5 ||
+		s0->tagByte6 != s1->tagByte6 ||
+		s0->tagByte7 != s1->tagByte7 ||
+		s0->ecc1[0]  != s1->ecc1[0]  ||
+		s0->ecc1[1]  != s1->ecc1[1]  ||
+		s0->ecc1[2]  != s1->ecc1[2]  ||
+		s0->ecc2[0]  != s1->ecc2[0]  ||
+		s0->ecc2[1]  != s1->ecc2[1]  ||
+		s0->ecc2[2]  != s1->ecc2[2] )
+		{
+			return 0;
+		}
+	
+	return 1;
+}
 
 
 ///////////////////////// Object management //////////////////
@@ -252,12 +441,14 @@ static __u16 yaffs_CalcNameSum(const char *name)
 	__u16 i = 1;
 	
 	__u8 *bname = (__u8 *)name;
-	
-	while (*bname)
+	if(bname)
 	{
-		sum += (*bname) * i;
-		i++;
-		bname++;
+		while (*bname)
+		{
+			sum += (*bname) * i;
+			i++;
+			bname++;
+		}
 	}
 	return sum;
 }
@@ -271,7 +462,8 @@ void yaffs_CalcECC(const __u8 *data, yaffs_Spare *spare)
 
 void yaffs_CalcTagsECC(yaffs_Tags *tags)
 {
-	// Todo don't do anything yet. Need to calculate ecc
+	// Calculate an ecc
+	
 	unsigned char *b = ((yaffs_TagsUnion *)tags)->asBytes;
 	unsigned  i,j;
 	unsigned  ecc = 0;
@@ -281,7 +473,7 @@ void yaffs_CalcTagsECC(yaffs_Tags *tags)
 	
 	for(i = 0; i < 8; i++)
 	{
-		for(j = 1; j &0x7f; j<<=1)
+		for(j = 1; j &0xff; j<<=1)
 		{
 			bit++;
 			if(b[i] & j)
@@ -498,6 +690,7 @@ static yaffs_Tnode *yaffs_FindLevel0Tnode(yaffs_Device *dev,yaffs_FileStructure
 		YALERT(str);
 		return NULL;
 	}
+	
 	if(chunkId > YAFFS_MAX_CHUNK_ID)
 	{
 		char str[50];
@@ -508,7 +701,7 @@ static yaffs_Tnode *yaffs_FindLevel0Tnode(yaffs_Device *dev,yaffs_FileStructure
 
 	// First check we're tall enough (ie enough topLevel)
 	
-	i = chunkId >> (dev->chunkGroupBits + YAFFS_TNODES_LEVEL0_BITS);
+	i = chunkId >> (/*dev->chunkGroupBits  + */YAFFS_TNODES_LEVEL0_BITS);
 	requiredTallness = 0;
 	while(i)
 	{
@@ -527,7 +720,7 @@ static yaffs_Tnode *yaffs_FindLevel0Tnode(yaffs_Device *dev,yaffs_FileStructure
 	// Traverse down to level 0
 	while (level > 0 && tn)
 	{
-	    tn = tn->internal[(chunkId >>(dev->chunkGroupBits + YAFFS_TNODES_LEVEL0_BITS + (level-1) * YAFFS_TNODES_INTERNAL_BITS)) & 
+	    tn = tn->internal[(chunkId >>(/* dev->chunkGroupBits + */ YAFFS_TNODES_LEVEL0_BITS + (level-1) * YAFFS_TNODES_INTERNAL_BITS)) & 
 	                       YAFFS_TNODES_INTERNAL_MASK]; 
 		level--;
 	
@@ -554,7 +747,7 @@ static yaffs_Tnode *yaffs_AddOrFindLevel0Tnode(yaffs_Device *dev, yaffs_FileStru
 	__u32 l;
 	
 	
-	T(("AddOrFind topLevel=%d, chunk=%d",fStruct->topLevel,chunkId));
+	//T((TSTR("AddOrFind topLevel=%d, chunk=%d"),fStruct->topLevel,chunkId));
 	
 	// Check sane level and page Id
 	if(fStruct->topLevel < 0 || fStruct->topLevel > YAFFS_TNODES_MAX_LEVEL)
@@ -575,7 +768,7 @@ static yaffs_Tnode *yaffs_AddOrFindLevel0Tnode(yaffs_Device *dev, yaffs_FileStru
 	
 	// First check we're tall enough (ie enough topLevel)
 	
-	i = chunkId >> (dev->chunkGroupBits + YAFFS_TNODES_LEVEL0_BITS);
+	i = chunkId >> (/*dev->chunkGroupBits + */YAFFS_TNODES_LEVEL0_BITS);
 	requiredTallness = 0;
 	while(i)
 	{
@@ -583,7 +776,7 @@ static yaffs_Tnode *yaffs_AddOrFindLevel0Tnode(yaffs_Device *dev, yaffs_FileStru
 		requiredTallness++;
 	}
 	
-	T((" required=%d",requiredTallness));
+	//T((TSTR(" required=%d"),requiredTallness));
 	
 	
 	if(requiredTallness > fStruct->topLevel)
@@ -591,7 +784,7 @@ static yaffs_Tnode *yaffs_AddOrFindLevel0Tnode(yaffs_Device *dev, yaffs_FileStru
 		// Not tall enough,gotta make the tree taller
 		for(i = fStruct->topLevel; i < requiredTallness; i++)
 		{
-			T((" add new top"));
+			//T((TSTR(" add new top")));
 			
 			tn = yaffs_GetTnode(dev);
 			
@@ -616,14 +809,14 @@ static yaffs_Tnode *yaffs_AddOrFindLevel0Tnode(yaffs_Device *dev, yaffs_FileStru
 	tn = fStruct->top;
 	while (l > 0 && tn)
 	{
-		i = (chunkId >> (dev->chunkGroupBits +YAFFS_TNODES_LEVEL0_BITS + (l-1) * YAFFS_TNODES_INTERNAL_BITS)) & 
+		i = (chunkId >> (/*dev->chunkGroupBits + */YAFFS_TNODES_LEVEL0_BITS + (l-1) * YAFFS_TNODES_INTERNAL_BITS)) & 
 	                       YAFFS_TNODES_INTERNAL_MASK;
 			       
-		T((" [%d:%d]",l,i));
+		//T((TSTR(" [%d:%d]"),l,i));
 		
 	    if(!tn->internal[i])
 	    {
-	    	T((" added"));
+	    	//T((TSTR(" added")));
 		
 	    	tn->internal[i] = yaffs_GetTnode(dev);
 	    }
@@ -633,14 +826,97 @@ static yaffs_Tnode *yaffs_AddOrFindLevel0Tnode(yaffs_Device *dev, yaffs_FileStru
 	
 	}
 	
-	T(("\n"));
+	//TSTR(TENDSTR)));
 	
 	return tn;		
 }
 
+// DeleteWorker scans backwards through the tnode tree and deletes all the
+// chunks and tnodes in the file
+
+static void yaffs_DeleteWorker(yaffs_Object *in, yaffs_Tnode *tn, __u32 level, int chunkOffset,int *limit)
+{
+	int i;
+	int chunkInInode;
+	int theChunk;
+	yaffs_Tags tags;
+	int found;
+	int chunkDeleted;
+	
+	
+	if(tn)
+	{
+		if(level > 0)
+		{
+		
+			for(i = YAFFS_NTNODES_INTERNAL -1; i >= 0 && (!limit || *limit > 0); i--)
+			{
+			    if(tn->internal[i])
+		    	{
+					yaffs_DeleteWorker(in,tn->internal[i],level - 1,
+										(chunkOffset << YAFFS_TNODES_INTERNAL_BITS ) + i ,limit);
+					yaffs_FreeTnode(in->myDev,tn->internal[i]);
+			    	tn->internal[i] = NULL;
+			    }
+		    
+			}
+		}
+		else if(level == 0)
+		{
+			for(i = YAFFS_NTNODES_LEVEL0 -1; i >= 0; i--) //NB Don't apply the limit here, always delete a whole level0
+			{
+			    if(tn->level0[i])
+		    	{
+					int j;
+					
+					chunkInInode = (chunkOffset << YAFFS_TNODES_LEVEL0_BITS ) + i;
+					
+					theChunk =  tn->level0[i] << in->myDev->chunkGroupBits;
+
+					// Now we need to search for it
+					for(j = 0,found = 0; theChunk && j < in->myDev->chunkGroupSize && !found; j++)
+					{
+						yaffs_ReadChunkTagsFromNAND(in->myDev,theChunk,&tags,&chunkDeleted);
+						if(yaffs_TagsMatch(&tags,in->objectId,chunkInInode,chunkDeleted))
+						{
+							// found it;
+							found = 1;
+					
+						}
+						else
+						{
+							theChunk++;
+						}
+					}
+					
+					if(found)
+					{
+						yaffs_DeleteChunk(in->myDev,theChunk);
+						in->nDataChunks--;
+						if(limit)
+						{ 
+							*limit = *limit-1;
+						}
+					
+					}
+					
+			    	tn->level0[i] = 0;
+			    }
+		    
+			}
+			
+		}
+		
+	}
+	
+}
+
+
+
 
 // Pruning removes any part of the file structure tree that is beyond the
-// bounds of the file.
+// bounds of the file (ie that does not point to chunks).
+//
 // A file should only get pruned when its size is reduced.
 //
 // Before pruning, the chunks must be pulled from the tree and the
@@ -810,6 +1086,7 @@ static yaffs_Object *yaffs_AllocateEmptyObject(yaffs_Device *dev)
 		// Now sweeten it up...
 	
 		memset(tn,0,sizeof(yaffs_Object));
+		tn->myDev = dev;
 		tn->chunkId = -1;
 		tn->variantType = YAFFS_OBJECT_TYPE_UNKNOWN;
 		INIT_LIST_HEAD(&(tn->hardLinks));
@@ -838,6 +1115,8 @@ static yaffs_Object *yaffs_CreateFakeDirectory(yaffs_Device *dev,int number,__u3
 		obj->fake = 1;			// it is fake so it has no NAND presence...
 		obj->renameAllowed= 0;	// ... and we're not allowed to rename it...
 		obj->unlinkAllowed= 0;	// ... or unlink it
+		obj->deleted = 0;
+		obj->unlinked = 0;
 		obj->st_mode = mode;
 		obj->myDev = dev;
 		obj->chunkId = 0; // Not a valid chunk.
@@ -1017,7 +1296,7 @@ yaffs_Object *yaffs_FindObjectByNumber(yaffs_Device *dev,int number)
 	
 	list_for_each(i,&dev->objectBucket[bucket].list)
 	{
-		// Lookm if it is in the list
+		// Look if it is in the list
 		in = list_entry(i, yaffs_Object,hashLink);
 		if(in->objectId == number)
 		{
@@ -1048,7 +1327,6 @@ yaffs_Object *yaffs_CreateNewObject(yaffs_Device *dev,int number,yaffs_ObjectTyp
 		theObject->renameAllowed = 1;
 		theObject->unlinkAllowed = 1;
 		theObject->objectId = number;
-		theObject->myDev = dev;
 		yaffs_HashObject(theObject);
 		theObject->variantType = type;
 		theObject->st_atime = theObject->st_mtime =	theObject->st_ctime = CURRENT_TIME;
@@ -1057,6 +1335,7 @@ yaffs_Object *yaffs_CreateNewObject(yaffs_Device *dev,int number,yaffs_ObjectTyp
 		{
 			case YAFFS_OBJECT_TYPE_FILE: 
 				theObject->variant.fileVariant.fileSize = 0;
+				theObject->variant.fileVariant.scannedFileSize = 0;
 				theObject->variant.fileVariant.topLevel = 0;
 				theObject->variant.fileVariant.top  = yaffs_GetTnode(dev);
 				break;
@@ -1069,8 +1348,12 @@ yaffs_Object *yaffs_CreateNewObject(yaffs_Device *dev,int number,yaffs_ObjectTyp
 			case YAFFS_OBJECT_TYPE_HARDLINK:
 				// No action required
 				break;
+			case YAFFS_OBJECT_TYPE_SPECIAL:
+				// No action required
+				break;
 			case YAFFS_OBJECT_TYPE_UNKNOWN:
 				// todo this should not happen
+				break;
 		}
 	}
 	
@@ -1081,7 +1364,7 @@ yaffs_Object *yaffs_FindOrCreateObjectByNumber(yaffs_Device *dev, int number,yaf
 {
 	yaffs_Object *theObject = NULL;
 	
-	if(number >= 0)
+	if(number > 0)
 	{
 		theObject = yaffs_FindObjectByNumber(dev,number);
 	}
@@ -1113,6 +1396,7 @@ char *yaffs_CloneString(const char *str)
 // Mknod (create) a new object.
 // equivalentObject only has meaning for a hard link;
 // aliasString only has meaning for a sumlink.
+// rdev only has meaning for devices (a subset of special objects)
 yaffs_Object *yaffs_MknodObject( yaffs_ObjectType type,
 								 yaffs_Object *parent,
 								 const char *name, 
@@ -1120,7 +1404,8 @@ yaffs_Object *yaffs_MknodObject( yaffs_ObjectType type,
 								 __u32 uid,
 								 __u32 gid,
 								 yaffs_Object *equivalentObject,
-								 const char *aliasString)
+								 const char *aliasString,
+								 __u32 rdev)
 {
 	yaffs_Object *in;
 
@@ -1141,9 +1426,12 @@ yaffs_Object *yaffs_MknodObject( yaffs_ObjectType type,
 		in->variantType = type;
 
 		in->st_mode  = mode;
+		in->st_rdev  = rdev;
 		in->st_uid   = uid;
 		in->st_gid   = gid;
 		in->st_atime = 	in->st_mtime =	in->st_ctime = CURRENT_TIME;
+		
+		in->nDataChunks = 0;
 
 		in->sum = yaffs_CalcNameSum(name);
 		in->dirty = 1;
@@ -1165,10 +1453,18 @@ yaffs_Object *yaffs_MknodObject( yaffs_ObjectType type,
 				break;
 			case YAFFS_OBJECT_TYPE_FILE: // do nothing
 			case YAFFS_OBJECT_TYPE_DIRECTORY: // do nothing
+			case YAFFS_OBJECT_TYPE_SPECIAL: // do nothing
 			case YAFFS_OBJECT_TYPE_UNKNOWN:
+				break;
 		}
 
-		yaffs_UpdateObjectHeader(in,name);
+		if(yaffs_GetNumberOfFreeChunks(dev) <= 0 ||
+		   yaffs_UpdateObjectHeader(in,name,0) < 0)
+		{
+			// Could not create the object header, fail the creation
+			yaffs_UnlinkWorker(in);
+			in = NULL;
+		}
 
 	}
 	
@@ -1177,17 +1473,22 @@ yaffs_Object *yaffs_MknodObject( yaffs_ObjectType type,
 
 yaffs_Object *yaffs_MknodFile(yaffs_Object *parent,const char *name, __u32 mode, __u32 uid, __u32 gid)
 {
-	return yaffs_MknodObject(YAFFS_OBJECT_TYPE_FILE,parent,name,mode,uid,gid,NULL,NULL);
+	return yaffs_MknodObject(YAFFS_OBJECT_TYPE_FILE,parent,name,mode,uid,gid,NULL,NULL,0);
 }
 
 yaffs_Object *yaffs_MknodDirectory(yaffs_Object *parent,const char *name, __u32 mode, __u32 uid, __u32 gid)
 {
-	return yaffs_MknodObject(YAFFS_OBJECT_TYPE_DIRECTORY,parent,name,mode,uid,gid,NULL,NULL);
+	return yaffs_MknodObject(YAFFS_OBJECT_TYPE_DIRECTORY,parent,name,mode,uid,gid,NULL,NULL,0);
+}
+
+yaffs_Object *yaffs_MknodSpecial(yaffs_Object *parent,const char *name, __u32 mode, __u32 uid, __u32 gid, __u32 rdev)
+{
+	return yaffs_MknodObject(YAFFS_OBJECT_TYPE_DIRECTORY,parent,name,mode,uid,gid,NULL,NULL,rdev);
 }
 
 yaffs_Object *yaffs_MknodSymLink(yaffs_Object *parent,const char *name, __u32 mode, __u32 uid, __u32 gid,const char *alias)
 {
-	return yaffs_MknodObject(YAFFS_OBJECT_TYPE_SYMLINK,parent,name,mode,uid,gid,NULL,alias);
+	return yaffs_MknodObject(YAFFS_OBJECT_TYPE_SYMLINK,parent,name,mode,uid,gid,NULL,alias,0);
 }
 
 // NB yaffs_Link returns the object id of the equivalent object.
@@ -1196,7 +1497,7 @@ yaffs_Object *yaffs_Link(yaffs_Object *parent, const char *name, yaffs_Object *e
 	// Get the real object in case we were fed a hard link as an equivalent object
 	equivalentObject = yaffs_GetEquivalentObject(equivalentObject);
 	
-	if(yaffs_MknodObject(YAFFS_OBJECT_TYPE_HARDLINK,parent,name,0,0,0,equivalentObject,NULL))
+	if(yaffs_MknodObject(YAFFS_OBJECT_TYPE_HARDLINK,parent,name,0,0,0,equivalentObject,NULL,0))
 	{
 		return equivalentObject;
 	}
@@ -1210,23 +1511,31 @@ yaffs_Object *yaffs_Link(yaffs_Object *parent, const char *name, yaffs_Object *e
 
 static int yaffs_ChangeObjectName(yaffs_Object *obj, yaffs_Object *newDir, const char *newName)
 {
-	//yaffs_Device *dev = obj->myDev;
+	int unlinkOp;
 
 	if(newDir == NULL)
 	{
 		newDir = obj->parent; // use the old directory
 	}
+
+	unlinkOp = (newDir == obj->myDev->unlinkedDir && obj->variantType == YAFFS_OBJECT_TYPE_FILE);
 	
-	// Only proceed if the new name does not exist and
-	// if we're putting it into a directory.
-	if(!yaffs_FindObjectByName(newDir,newName) &&
-	    newDir->variantType == YAFFS_OBJECT_TYPE_DIRECTORY)
+	// If the object is a file going into the unlinked directory, then it is OK to just stuff it in since
+	// duplicate names are allowed.
+	// Otherwise only proceed if the new name does not exist and if we're putting it into a directory.
+	if( unlinkOp||
+	    (!yaffs_FindObjectByName(newDir,newName) &&
+	     newDir->variantType == YAFFS_OBJECT_TYPE_DIRECTORY))
 	{
 		obj->sum = yaffs_CalcNameSum(newName);
 		obj->dirty = 1;
+		
 		yaffs_AddObjectToDirectory(newDir,obj);
 		
-		if(yaffs_UpdateObjectHeader(obj,newName) >= 0)
+		if(unlinkOp) obj->unlinked = 1;
+		
+		
+		if(yaffs_UpdateObjectHeader(obj,newName,0) >= 0)
 		{
 			return YAFFS_OK;
 		}
@@ -1292,7 +1601,7 @@ void yaffs_ObjectTest(yaffs_Device *dev)
 	
 	for(j = 0; j < 10; j++)
 	{
-		T(("%d\n",j));
+		//T(("%d\n",j));
 		
 		for(i = 0; i < 1000; i++)
 		{
@@ -1311,7 +1620,7 @@ void yaffs_ObjectTest(yaffs_Device *dev)
 		{
 			if(yaffs_FindObjectByNumber(dev,inNo[i]) != in[i])
 			{
-				T(("Differnce in look up test\n"));
+				//T(("Differnce in look up test\n"));
 			}
 			else
 			{
@@ -1338,11 +1647,18 @@ void yaffs_ObjectTest(yaffs_Device *dev)
 /////////////////////////// Block Management and Page Allocation ///////////////////
 
 
-static void yaffs_InitialiseBlocks(yaffs_Device *dev)
+static int yaffs_InitialiseBlocks(yaffs_Device *dev,int nBlocks)
 {
-	dev->blockInfo = YMALLOC(dev->nBlocks * sizeof(yaffs_BlockInfo));
-	memset(dev->blockInfo,0,dev->nBlocks * sizeof(yaffs_BlockInfo));
 	dev->allocationBlock = -1; // force it to get a new one
+	//Todo we're assuming the malloc will pass.
+	dev->blockInfo = YMALLOC(nBlocks * sizeof(yaffs_BlockInfo));
+	if(dev->blockInfo)
+	{
+		memset(dev->blockInfo,0,nBlocks * sizeof(yaffs_BlockInfo));
+		return YAFFS_OK;
+	}
+	return YAFFS_FAIL;
+	
 }
 
 static void yaffs_DeinitialiseBlocks(yaffs_Device *dev)
@@ -1361,6 +1677,7 @@ static int yaffs_FindDirtiestBlock(yaffs_Device *dev)
 	int i;
 	int dirtiest = -1;
 	int pagesInUse = 100; // silly big number
+	yaffs_BlockInfo *bi;
 	
 	for(i = dev->startBlock; i <= dev->endBlock && pagesInUse > 2 ; i++)
 	{
@@ -1370,11 +1687,13 @@ static int yaffs_FindDirtiestBlock(yaffs_Device *dev)
 			b =  dev->startBlock;
 		}
 		
-		if(dev->blockInfo[b].blockState == YAFFS_BLOCK_STATE_FULL &&
-		   (dev->blockInfo)[b].pagesInUse < pagesInUse)
+		bi = yaffs_GetBlockInfo(dev,b);
+		
+		if(bi->blockState == YAFFS_BLOCK_STATE_FULL &&
+		   bi->pagesInUse < pagesInUse)
 		{
 			dirtiest = b;
-			pagesInUse = (dev->blockInfo)[b].pagesInUse;
+			pagesInUse = bi->pagesInUse;
 		}
 	}
 	
@@ -1384,36 +1703,63 @@ static int yaffs_FindDirtiestBlock(yaffs_Device *dev)
 }
 
 
-static int yaffs_FindBlockForAllocation(yaffs_Device *dev,int useReserve)
+static void yaffs_BlockBecameDirty(yaffs_Device *dev,int blockNo)
+{
+	yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev,blockNo);
+	
+	int erasedOk = 0;
+	
+	// If the block is still healthy erase it and mark as clean.
+	// If the block has had a data failure, then retire it.
+	bi->blockState = YAFFS_BLOCK_STATE_DIRTY;
+
+	if(!bi->needsRetiring)
+	{
+		erasedOk = yaffs_EraseBlockInNAND(dev,blockNo);
+		if(!erasedOk)
+		{
+			T((TSTR("**>> Erasure failed %d" TENDSTR),blockNo));
+		}
+	}
+	
+	if( erasedOk )
+	{
+		bi->blockState = YAFFS_BLOCK_STATE_EMPTY;
+		dev->nErasedBlocks++;
+		bi->pagesInUse = 0;
+		bi->pageBits = 0;
+	
+		T((TSTR("Erased block %d" TENDSTR),blockNo));
+	}
+	else
+	{
+		yaffs_RetireBlock(dev,blockNo);
+		T((TSTR("**>> Block %d retired" TENDSTR),blockNo));
+	}
+}
+
+
+static int yaffs_FindBlockForAllocation(yaffs_Device *dev)
 {
 	int i;
+	yaffs_BlockInfo *bi;
 	
-	if(useReserve && dev->nErasedBlocks < 1)
+	if(dev->nErasedBlocks < 1)
 	{
 		// Hoosterman we've got a problem.
 		// Can't get space to gc
 		return -1;
 	}
-	else if(!useReserve && dev->nErasedBlocks <= YAFFS_RESERVED_BLOCKS)
-	{
-		// We are not in GC, so we hold some in reserve so we can get
-		// a gc done.
-	}
 	
 	// Find an empty block.
 	
 	for(i = dev->startBlock; i <= dev->endBlock; i++)
 	{
-			
-		if(dev->blockInfo[i].blockState == YAFFS_BLOCK_STATE_EMPTY)
+		bi = yaffs_GetBlockInfo(dev,i);
+		if(bi->blockState == YAFFS_BLOCK_STATE_EMPTY)
 		{
-			dev->blockInfo[i].blockState = YAFFS_BLOCK_STATE_ALLOCATING;
-			dev->nErasedBlocks--;
-			if(dev->nErasedBlocks <= YAFFS_RESERVED_BLOCKS)
-			{
-				dev->garbageCollectionRequired = 1;
-			}
-			
+			bi->blockState = YAFFS_BLOCK_STATE_ALLOCATING;
+			dev->nErasedBlocks--;			
 			return i;
 		}
 	}
@@ -1422,41 +1768,34 @@ static int yaffs_FindBlockForAllocation(yaffs_Device *dev,int useReserve)
 }
 
 
-static void yaffs_BlockBecameDirty(yaffs_Device *dev,int blockNo)
-{
-	yaffs_BlockInfo *bi = &dev->blockInfo[blockNo];
-	
-	// Mark as dirty, erase it and mark as clean.
-	bi->blockState = YAFFS_BLOCK_STATE_DIRTY;
-	yaffs_EraseBlockInNAND(dev,blockNo);
-	bi->blockState = YAFFS_BLOCK_STATE_EMPTY;
-	dev->nErasedBlocks++;
-	bi->pagesInUse = 0;
-	bi->pageBits = 0;
-	
-	T(("Erased block %d\n",blockNo));
-}
-
 
 static int yaffs_AllocateChunk(yaffs_Device *dev,int useReserve)
 {
 	int retVal;
+	yaffs_BlockInfo *bi;
 	
 	if(dev->allocationBlock < 0)
 	{
 		// Get next block to allocate off
-		dev->allocationBlock = yaffs_FindBlockForAllocation(dev,useReserve);
+		dev->allocationBlock = yaffs_FindBlockForAllocation(dev);
 		dev->allocationPage = 0;
 	}
 	
+	if(!useReserve &&  dev->nErasedBlocks <= YAFFS_RESERVED_BLOCKS)
+	{
+		// Not enough space to allocate unless we're allowed to use the reserve.
+		return -1;
+	}
+	
 	// Next page please....
 	if(dev->allocationBlock >= 0)
 	{
+		bi = yaffs_GetBlockInfo(dev,dev->allocationBlock);
+		
 		retVal = (dev->allocationBlock * YAFFS_CHUNKS_PER_BLOCK) + 
 			  	  dev->allocationPage;
-		dev->blockInfo[dev->allocationBlock].pagesInUse++;
-		dev->blockInfo[dev->allocationBlock].pageBits |= 
-				(1 << (dev->allocationPage));
+		bi->pagesInUse++;
+		bi->pageBits |= (1 << (dev->allocationPage));
 
 		dev->allocationPage++;
 		
@@ -1465,20 +1804,15 @@ static int yaffs_AllocateChunk(yaffs_Device *dev,int useReserve)
 		// If the block is full set the state to full
 		if(dev->allocationPage >= YAFFS_CHUNKS_PER_BLOCK)
 		{
-			dev->blockInfo[dev->allocationBlock].blockState = YAFFS_BLOCK_STATE_FULL;
+			bi->blockState = YAFFS_BLOCK_STATE_FULL;
 			dev->allocationBlock = -1;
 		}
 
-#ifdef YAFFS_PARANOID
-		if(yaffs_CheckChunkErased(dev,retVal) == YAFFS_FAIL)
-		{
-			T(("..................Trying to allocate non-erased page %d\n",retVal));
-		}
-#endif		
+
 		return retVal;
 		
 	}
-	T(("!!!!!!!!! Allocator out !!!!!!!!!!!!!!!!!\n"));
+	T((TSTR("!!!!!!!!! Allocator out !!!!!!!!!!!!!!!!!" TENDSTR)));
 
 	return -1;	
 }
@@ -1495,11 +1829,11 @@ int  yaffs_GarbageCollectBlock(yaffs_Device *dev,int block)
 	yaffs_Tags  tags;
 		__u8  buffer[YAFFS_BYTES_PER_CHUNK];
 	
-	yaffs_BlockInfo *bi = &dev->blockInfo[block];
+	yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev,block);
 	
 	yaffs_Object *object;
 
-	T(("Collecting block %d n %d bits %x\n",block, bi->pagesInUse, bi->pageBits));	
+	//T(("Collecting block %d n %d bits %x\n",block, bi->pagesInUse, bi->pageBits));	
 	
 	for(mask = 1,oldChunk = block * YAFFS_CHUNKS_PER_BLOCK; 
 	    mask && bi->pageBits;
@@ -1510,9 +1844,11 @@ int  yaffs_GarbageCollectBlock(yaffs_Device *dev,int block)
 			
 			// This page is in use and needs to be copied off
 			
-			T(("copying page %x from %d to %d\n",mask,oldChunk,newChunk));
+			dev->nGCCopies++;
 			
-			yaffs_ReadChunkFromNAND(dev,oldChunk,buffer, &spare);
+			//T(("copying page %x from %d to %d\n",mask,oldChunk,newChunk));
+			
+			yaffs_ReadChunkFromNAND(dev,oldChunk,buffer, &spare,1);
 			
 			yaffs_GetTagsFromSpare(&spare,&tags);
 			tags.serialNumber++;
@@ -1559,35 +1895,98 @@ int  yaffs_GarbageCollectBlock(yaffs_Device *dev,int block)
 	return YAFFS_OK;
 }
 
-int yaffs_CheckGarbageCollection(yaffs_Device *dev)
+
+static yaffs_Object *yaffs_FindDeletedUnlinkedFile(yaffs_Device *dev)
 {
-	int block;
-	
-	if(dev->garbageCollectionRequired)
+	// todo find a file to delete
+	struct list_head *i;	
+	yaffs_Object *l;
+
+
+	// To the free chunks add the chunks that are in the deleted unlinked files.
+	list_for_each(i,&dev->unlinkedDir->variant.directoryVariant.children)
 	{
-		dev->garbageCollectionRequired = 0;
-		block = yaffs_FindDirtiestBlock(dev);
-		if(block >= 0)
-		{
-			return yaffs_GarbageCollectBlock(dev,block);
-		}	
-		else
+		l = list_entry(i, yaffs_Object,siblings);
+		if(l->deleted)
 		{
-			return YAFFS_FAIL;
+			return l;			
 		}
-	}
-
-	return YAFFS_OK;
+	}	
+	return NULL;
 }
 
-
-//////////////////////////// TAGS ///////////////////////////////////////
-
-static void yaffs_LoadTagsIntoSpare(yaffs_Spare *sparePtr, yaffs_Tags *tagsPtr)
+static void yaffs_DoUnlinkedFileDeletion(yaffs_Device *dev)
 {
-	yaffs_TagsUnion *tu = (yaffs_TagsUnion *)tagsPtr;
+	// This does background deletion on unlinked files.. only deleted ones.
+	// If we don't have a file we're working on then find one
+	if(!dev->unlinkedDeletion && dev->nDeletedFiles > 0)
+	{
+		dev->unlinkedDeletion = yaffs_FindDeletedUnlinkedFile(dev);
+	}
 	
-	yaffs_CalcTagsECC(tagsPtr);
+	// OK, we're working on a file...
+	if(dev->unlinkedDeletion)
+	{
+		yaffs_Object *obj = dev->unlinkedDeletion;
+		int limit;
+		limit = 50; // Max number of chunks to delete in a file. NB this can be exceeded, but not by much.
+		yaffs_DeleteWorker(obj, obj->variant.fileVariant.top, obj->variant.fileVariant.topLevel, 0,&limit);
+		if(obj->nDataChunks == 0)
+		{
+			// Done all the deleting of data chunks.
+			// Now dump the header and clean up
+			yaffs_DoGenericObjectDeletion(dev->unlinkedDeletion);
+			dev->nDeletedFiles--;
+			dev->unlinkedDeletion = NULL;	
+		}
+	}
+}
+
+static int yaffs_CheckGarbageCollection(yaffs_Device *dev)
+{
+	int block;
+	
+	yaffs_DoUnlinkedFileDeletion(dev);
+	
+	if(dev->nErasedBlocks <= (YAFFS_RESERVED_BLOCKS + YAFFS_GARBAGE_COLLECT_LOW_WATER))
+	{
+		dev->garbageCollectionRequired = 1;
+	}	
+	
+	if(dev->garbageCollectionRequired)
+	{
+		dev->garbageCollections++;
+		dev->garbageCollectionRequired = 0;
+		if(dev->blockSelectedForGC >= 0)
+		{
+			block = dev->blockSelectedForGC;
+		}
+		else
+		{
+			block = yaffs_FindDirtiestBlock(dev);
+		}
+		
+		if(block >= 0)
+		{
+			return yaffs_GarbageCollectBlock(dev,block);
+		}	
+		else
+		{
+			return YAFFS_FAIL;
+		}
+	}
+
+	return YAFFS_OK;
+}
+
+
+//////////////////////////// TAGS ///////////////////////////////////////
+
+static void yaffs_LoadTagsIntoSpare(yaffs_Spare *sparePtr, yaffs_Tags *tagsPtr)
+{
+	yaffs_TagsUnion *tu = (yaffs_TagsUnion *)tagsPtr;
+	
+	yaffs_CalcTagsECC(tagsPtr);
 	
 	sparePtr->tagByte0 = tu->asBytes[0];
 	sparePtr->tagByte1 = tu->asBytes[1];
@@ -1620,13 +2019,14 @@ static void yaffs_SpareInitialise(yaffs_Spare *spare)
 	memset(spare,0xFF,sizeof(yaffs_Spare));
 }
 
-static int yaffs_ReadChunkTagsFromNAND(yaffs_Device *dev,int chunkInNAND, yaffs_Tags *tags)
+static int yaffs_ReadChunkTagsFromNAND(yaffs_Device *dev,int chunkInNAND, yaffs_Tags *tags, int *chunkDeleted)
 {
 	if(tags)
 	{
 		yaffs_Spare spare;
-		if(yaffs_ReadChunkFromNAND(dev,chunkInNAND,NULL,&spare) == YAFFS_OK)
+		if(yaffs_ReadChunkFromNAND(dev,chunkInNAND,NULL,&spare,1) == YAFFS_OK)
 		{
+			*chunkDeleted = (yaffs_CountBits(spare.pageStatus) < 7) ? 1 : 0;
 			yaffs_GetTagsFromSpare(&spare,tags);
 			return YAFFS_OK;
 		}
@@ -1694,6 +2094,13 @@ static int yaffs_WriteNewChunkWithTagsToNAND(yaffs_Device *dev, const __u8 *buff
 	
 }
 
+static int yaffs_TagsMatch(const yaffs_Tags *tags, int objectId, int chunkInObject, int chunkDeleted)
+{
+	return 	(  tags->chunkId == chunkInObject &&
+			   tags->objectId == objectId &&
+			   !chunkDeleted) ? 1 : 0;
+	
+}
 
 
 
@@ -1705,6 +2112,8 @@ int yaffs_FindChunkInFile(yaffs_Object *in,int chunkInInode,yaffs_Tags *tags)
     yaffs_Tags localTags;
     int i;
     int found = 0;
+    int chunkDeleted;
+    
     yaffs_Device *dev = in->myDev;
     
     
@@ -1723,9 +2132,8 @@ int yaffs_FindChunkInFile(yaffs_Object *in,int chunkInInode,yaffs_Tags *tags)
 		// Now we need to do the shifting etc and search for it
 		for(i = 0,found = 0; theChunk && i < dev->chunkGroupSize && !found; i++)
 		{
-			yaffs_ReadChunkTagsFromNAND(dev,theChunk,tags);
-			if(tags->chunkId == chunkInInode &&
-			tags->objectId == in->objectId)
+			yaffs_ReadChunkTagsFromNAND(dev,theChunk,tags,&chunkDeleted);
+			if(yaffs_TagsMatch(tags,in->objectId,chunkInInode,chunkDeleted))
 			{
 				// found it;
 				found = 1;
@@ -1748,6 +2156,7 @@ int yaffs_FindAndDeleteChunkInFile(yaffs_Object *in,int chunkInInode,yaffs_Tags
     int i;
     int found = 0;
     yaffs_Device *dev = in->myDev;
+    int chunkDeleted;
     
     if(!tags)
     {
@@ -1765,9 +2174,8 @@ int yaffs_FindAndDeleteChunkInFile(yaffs_Object *in,int chunkInInode,yaffs_Tags
 		// Now we need to do the shifting etc and search for it
 		for(i = 0,found = 0; theChunk && i < dev->chunkGroupSize && !found; i++)
 		{
-			yaffs_ReadChunkTagsFromNAND(dev,theChunk,tags);
-			if(tags->chunkId == chunkInInode &&
-			tags->objectId == in->objectId)
+			yaffs_ReadChunkTagsFromNAND(dev,theChunk,tags,&chunkDeleted);
+			if(yaffs_TagsMatch(tags,in->objectId,chunkInInode,chunkDeleted))
 			{
 				// found it;
 				found = 1;
@@ -1786,12 +2194,12 @@ int yaffs_FindAndDeleteChunkInFile(yaffs_Object *in,int chunkInInode,yaffs_Tags
     }
     else
     {
-    	T(("No level 0 found for %d\n", chunkInInode));
+    	//T(("No level 0 found for %d\n", chunkInInode));
     }
     
     if(!found)
     {
-    	T(("Could not find %d to delete\n",chunkInInode));
+    	//T(("Could not find %d to delete\n",chunkInInode));
     }
     return found ? theChunk : -1;
 }
@@ -1810,11 +2218,12 @@ static int yaffs_CheckFileSanity(yaffs_Object *in)
     yaffs_Tags localTags;
     yaffs_Tags *tags = &localTags;
     int theChunk;
+    int chunkDeleted;
     
     	
 	if(in->variantType != YAFFS_OBJECT_TYPE_FILE)
 	{
-		T(("Object not a file\n"));
+		//T(("Object not a file\n"));
 		return YAFFS_FAIL;
 	}
 	
@@ -1832,9 +2241,8 @@ static int yaffs_CheckFileSanity(yaffs_Object *in)
 			theChunk = tn->level0[chunk & YAFFS_TNODES_LEVEL0_MASK] << in->myDev->chunkGroupBits;
     
 
-				yaffs_ReadChunkTagsFromNAND(in->myDev,theChunk,tags);
-				if(tags->chunkId == chunk &&
-				tags->objectId == in->objectId)
+				yaffs_ReadChunkTagsFromNAND(in->myDev,theChunk,tags,&chunkDeleted);
+				if(yaffs_TagsMatch(tags,in->objectId,chunk,chunkDeleted))
 				{
 					// found it;
 				
@@ -1851,7 +2259,7 @@ static int yaffs_CheckFileSanity(yaffs_Object *in)
 		}
 		else
 		{
-			T(("No level 0 found for %d\n", chunk));
+			//T(("No level 0 found for %d\n", chunk));
 		}
 	}
 	
@@ -1869,8 +2277,16 @@ static int yaffs_PutChunkIntoFile(yaffs_Object *in,int chunkInInode, int chunkIn
 	yaffs_Tags newTags;
 	unsigned existingSerial, newSerial;
 	
+	int newChunkDeleted;
+	
 	
 	tn = yaffs_AddOrFindLevel0Tnode(dev,&in->variant.fileVariant, chunkInInode);
+	if(!tn)
+	{
+		return YAFFS_FAIL;
+	}
+
+	existingChunk = tn->level0[chunkInInode & YAFFS_TNODES_LEVEL0_MASK];		
 	
 	if(inScan)
 	{
@@ -1879,17 +2295,35 @@ static int yaffs_PutChunkIntoFile(yaffs_Object *in,int chunkInInode, int chunkIn
 		// happen when the power fails during a write, then only one
 		// chunk should ever be affected.
 	
-		existingChunk = tn->level0[chunkInInode & YAFFS_TNODES_LEVEL0_MASK];		
 		
 		if(existingChunk != 0)
 		{
+			// NB Right now existing chunk will not be real chunkId if the device >= 32MB
+			//    thus we have to do a FindChunkInFile to get the real chunk id.
+			//
 			// We have a duplicate now we need to decide which one to use
 			// To do this we get both sets of tags and compare serial numbers.
-			yaffs_ReadChunkTagsFromNAND(dev,chunkInInode, &newTags);
-			yaffs_ReadChunkTagsFromNAND(dev,existingChunk, &existingTags);
+			yaffs_ReadChunkTagsFromNAND(dev,chunkInNAND, &newTags,&newChunkDeleted);
+			
+			
+			// Do a proper find
+			existingChunk = yaffs_FindChunkInFile(in,chunkInInode, &existingTags);
+
+			if(existingChunk <=0)
+			{
+				//Hoosterman - how did this happen?
+				// todo
+			}
+
+			
+			// NB The deleted flags should be false, otherwise the chunks will 
+			// not be loaded during a scan
+			
 			newSerial = newTags.serialNumber;
 			existingSerial = existingTags.serialNumber;
-			if(((existingSerial+1) & 3) == newSerial)
+			
+			if( existingChunk <= 0 ||
+			    ((existingSerial+1) & 3) == newSerial)
 			{
 				// Use new
 				// Delete the old one and drop through to update the tnode
@@ -1899,13 +2333,19 @@ static int yaffs_PutChunkIntoFile(yaffs_Object *in,int chunkInInode, int chunkIn
 			{
 				// Use existing.
 				// Delete the new one and return early so that the tnode isn't changed
-				yaffs_DeleteChunk(dev,chunkInInode);
+				yaffs_DeleteChunk(dev,chunkInNAND);
 				return YAFFS_OK;
 			}
 		}
+
+	}
+		
+	if(existingChunk == 0)
+	{
+		in->nDataChunks++;
 	}
 	
-	tn->level0[chunkInInode & YAFFS_TNODES_LEVEL0_MASK] = chunkInNAND;
+	tn->level0[chunkInInode & YAFFS_TNODES_LEVEL0_MASK] = (chunkInNAND >> dev->chunkGroupBits);
 	
 	return YAFFS_OK;
 }
@@ -1918,7 +2358,7 @@ int yaffs_ReadChunkDataFromObject(yaffs_Object *in,int chunkInInode, __u8 *buffe
     
     if(chunkInNAND >= 0)
     {
-		return yaffs_ReadChunkFromNAND(in->myDev,chunkInNAND,buffer,NULL);
+		return yaffs_ReadChunkFromNAND(in->myDev,chunkInNAND,buffer,NULL,1);
 	}
 	else
 	{
@@ -1930,30 +2370,37 @@ int yaffs_ReadChunkDataFromObject(yaffs_Object *in,int chunkInInode, __u8 *buffe
 
 static void yaffs_DeleteChunk(yaffs_Device *dev,int chunkId)
 {
-	int block = chunkId / YAFFS_CHUNKS_PER_BLOCK;
-	int page = chunkId % YAFFS_CHUNKS_PER_BLOCK;
+	int block;
+	int page;
 	yaffs_Spare spare;
+	yaffs_BlockInfo *bi;
+	
+	if(chunkId <= 0) return;	
 		
+	block = chunkId / YAFFS_CHUNKS_PER_BLOCK;
+	page = chunkId % YAFFS_CHUNKS_PER_BLOCK;
 	yaffs_SpareInitialise(&spare);
 	
 	spare.pageStatus = 0; // To mark it as deleted.
 
 	
 	yaffs_WriteChunkToNAND(dev,chunkId,NULL,&spare);
+	yaffs_HandleUpdateChunk(dev,chunkId,&spare);
+	bi = yaffs_GetBlockInfo(dev,block);
 			
 	
 	// Pull out of the management area.
 	// If the whole block became dirty, this will kick off an erasure.
-	if(	dev->blockInfo[block].blockState == YAFFS_BLOCK_STATE_ALLOCATING ||
-	    dev->blockInfo[block].blockState == YAFFS_BLOCK_STATE_FULL)
+	if(	bi->blockState == YAFFS_BLOCK_STATE_ALLOCATING ||
+	    bi->blockState == YAFFS_BLOCK_STATE_FULL)
 	{
 		dev->nFreeChunks++;
 
-		dev->blockInfo[block].pageBits &= ~(1 << page);
-		dev->blockInfo[block].pagesInUse--;
+		bi->pageBits &= ~(1 << page);
+		bi->pagesInUse--;
 		
-		if(	dev->blockInfo[block].pagesInUse == 0 &&
-	    dev->blockInfo[block].blockState == YAFFS_BLOCK_STATE_FULL)
+		if(bi->pagesInUse == 0 &&
+	       bi->blockState == YAFFS_BLOCK_STATE_FULL)
 	    {
 	    	yaffs_BlockBecameDirty(dev,block);
 	    }
@@ -1961,7 +2408,7 @@ static void yaffs_DeleteChunk(yaffs_Device *dev,int chunkId)
 	}
 	else
 	{
-		T(("Bad news deleting chunk %d\n",chunkId));
+		// T(("Bad news deleting chunk %d\n",chunkId));
 	}
 	
 }
@@ -2053,7 +2500,7 @@ int yaffs_WriteChunkDataToObject(yaffs_Object *in,int chunkInInode, const __u8 *
 // UpdateObjectHeader updates the header on NAND for an object.
 // If name is not NULL, then that new name is used.
 //
-int yaffs_UpdateObjectHeader(yaffs_Object *in,const char *name)
+int yaffs_UpdateObjectHeader(yaffs_Object *in,const char *name, int force)
 {
 
 	yaffs_Device *dev = in->myDev;
@@ -2067,8 +2514,10 @@ int yaffs_UpdateObjectHeader(yaffs_Object *in,const char *name)
     
     yaffs_ObjectHeader *oh = (yaffs_ObjectHeader *)bufferNew;
     yaffs_ObjectHeader *ohOld = (yaffs_ObjectHeader *)bufferOld;
+
+	yaffs_INVALIDATECHUNKCACHE(in);
     
-    if(!in->fake)
+    if(!in->fake || force)
     {
   
 		yaffs_CheckGarbageCollection(dev);		
@@ -2079,7 +2528,7 @@ int yaffs_UpdateObjectHeader(yaffs_Object *in,const char *name)
     
 		if(prevChunkId >= 0)
 		{
-			yaffs_ReadChunkFromNAND(dev,prevChunkId,bufferOld,NULL);    	
+			yaffs_ReadChunkFromNAND(dev,prevChunkId,bufferOld,NULL,1);    	
 		}
 
 		// Header data
@@ -2091,18 +2540,31 @@ int yaffs_UpdateObjectHeader(yaffs_Object *in,const char *name)
 		oh->st_atime = in->st_atime;
 		oh->st_mtime = in->st_mtime;
 		oh->st_ctime = in->st_ctime;
+		oh->st_rdev = in->st_rdev;
 	
-		oh->parentObjectId = in->parent->objectId;
+		if(in->parent)
+		{
+			oh->parentObjectId = in->parent->objectId;
+		}
+		else
+		{
+			oh->parentObjectId = 0;
+		}
+		
 		oh->sum = in->sum;
 		if(name && *name)
 		{
 			memset(oh->name,0,YAFFS_MAX_NAME_LENGTH + 1);
 			strncpy(oh->name,name,YAFFS_MAX_NAME_LENGTH);
 		}
-		else
+		else if(prevChunkId)
 		{	
 			memcpy(oh->name, ohOld->name,YAFFS_MAX_NAME_LENGTH + 1);
 		}
+		else
+		{
+			memset(oh->name,0,YAFFS_MAX_NAME_LENGTH + 1);	
+		}
 	
 		switch(in->variantType)
 		{
@@ -2115,6 +2577,9 @@ int yaffs_UpdateObjectHeader(yaffs_Object *in,const char *name)
 			case YAFFS_OBJECT_TYPE_HARDLINK:
 				oh->equivalentObjectId = in->variant.hardLinkVariant.equivalentObjectId;
 				break;
+			case YAFFS_OBJECT_TYPE_SPECIAL:	
+				// Do nothing
+				break;
 			case YAFFS_OBJECT_TYPE_DIRECTORY:	
 				// Do nothing
 				break;
@@ -2182,6 +2647,118 @@ int yaffs_UpdateObjectHeader(yaffs_Object *in,const char *name)
 }
 
 
+/////////////////////// Short Read Cache ////////////////////////////////
+//	In many siturations where there is no high level buffering a lot of
+//	reads might be short sequential reads. eg. scanning a jpeg file.
+//	In these cases, a shoprt read cache can provide a huge perfomance benefit 
+//  with dumb-as-a-rock code.
+//  There are a limited number (~10) of cache chunks per device
+
+
+#ifdef CONFIG_YAFFS_SHORT_OP_CACHE
+
+// Invalidate all the cache pages associated with this object
+// Do this whenever ther file is modified... dumb as a rock remember!
+static void yaffs_InvalidateChunkCache(yaffs_Object *in)
+{
+	int i;
+	yaffs_Device *dev = in->myDev;
+	int id = in->objectId;
+	
+	for(i = 0; i < YAFFS_N_CACHE_CHUNKS; i++)
+	{
+		if(dev->srCache[i].objectId == id)
+		{
+			dev->srCache[i].objectId = 0;
+		}
+	}
+}
+
+
+// Grab us a chunk for use.
+// First look for an empty one. 
+// Then look for the least recently used one.
+static yaffs_ChunkCache *yaffs_GrabChunkCache(yaffs_Device *dev)
+{
+	int i;
+	int usage;
+	int theOne;
+	
+	for(i = 0; i < YAFFS_N_CACHE_CHUNKS; i++)
+	{
+		if(dev->srCache[i].objectId == 0)
+		{
+			//T(("Grabbing empty %d\n",i));
+			
+			return &dev->srCache[i];
+		}
+	}
+	
+	
+	usage = dev->srCache[i].lastUse;
+	theOne = 0;
+	
+	for(i = 1; i < YAFFS_N_CACHE_CHUNKS; i++)
+	{
+		if(dev->srCache[i].lastUse < usage)
+		{
+			usage = dev->srCache[i].lastUse;
+			theOne = i;
+		}
+	}
+	
+	//T(("Grabbing non-empty %d\n",theOne));
+	return  &dev->srCache[theOne];
+	
+}
+
+
+// Find a cached chunk
+static yaffs_ChunkCache *yaffs_FindChunkCache(yaffs_Device *dev, int objectId, int chunkId)
+{
+	int i;
+;
+	
+	for(i = 0; i < YAFFS_N_CACHE_CHUNKS; i++)
+	{
+		if(dev->srCache[i].objectId == objectId && 
+		   dev->srCache[i].chunkId == chunkId)
+		{
+			dev->cacheHits++;
+			
+			return &dev->srCache[i];
+		}
+	}
+	
+	return NULL;
+}
+
+// Mark the chunk for the least recently used algorithym
+static void yaffs_UseChunkCache(yaffs_Device *dev, yaffs_ChunkCache *cache)
+{
+	if( dev->srLastUse < 0 || 
+		dev->srLastUse > 1000000)
+	{
+		// Reset the cache usages
+		int i;
+		for(i = 1; i < YAFFS_N_CACHE_CHUNKS; i++)
+		{
+			dev->srCache[i].lastUse = 0;
+		}
+		dev->srLastUse = 0;
+	}
+
+	dev->srLastUse++;
+	
+	cache->lastUse = dev->srLastUse;
+
+}
+
+
+
+#endif
+
+
 
 ///////////////////////// File read/write ///////////////////////////////
 // Read and write have very similar structures.
@@ -2197,7 +2774,11 @@ int yaffs_ReadDataFromFile(yaffs_Object *in, __u8 * buffer, __u32 offset, int nB
 	
 //	yaffs_Device *dev = in->myDev;
 	
+#ifdef CONFIG_YAFFS_SHORT_OP_CACHE
+	yaffs_ChunkCache *cache;
+#else
 	__u8 localBuffer[YAFFS_BYTES_PER_CHUNK];
+#endif
 	
 	int chunk;
 	int start;
@@ -2224,10 +2805,25 @@ int yaffs_ReadDataFromFile(yaffs_Object *in, __u8 * buffer, __u32 offset, int nB
 		if(nToCopy != YAFFS_BYTES_PER_CHUNK)
 		{
 			// An incomplete start or end chunk (or maybe both start and end chunk)
+#ifdef CONFIG_YAFFS_SHORT_OP_CACHE
+			// If we can't find the data in the cache, then load it up.
+			cache = yaffs_FindChunkCache(in->myDev,in->objectId,chunk);
+			if(!cache)
+			{
+				cache = yaffs_GrabChunkCache(in->myDev);
+				cache->objectId = in->objectId;
+				cache->chunkId = chunk;
+				yaffs_ReadChunkDataFromObject(in,chunk,cache->data);		
+			}
+			
+			yaffs_UseChunkCache(in->myDev,cache);
+
+			memcpy(buffer,&cache->data[start],nToCopy);
+#else
 			// Read into the local buffer then copy...
-		
 			yaffs_ReadChunkDataFromObject(in,chunk,localBuffer);		
 			memcpy(buffer,&localBuffer[start],nToCopy);
+#endif
 		}
 		else
 		{
@@ -2259,6 +2855,8 @@ int yaffs_WriteDataToFile(yaffs_Object *in,const __u8 * buffer, __u32 offset, in
 	int endOfWrite = offset+nBytes;
 	int chunkWritten = 0;
 	
+	yaffs_INVALIDATECHUNKCACHE(in);
+	
 	while(n > 0 && chunkWritten >= 0)
 	{
 		chunk = offset / YAFFS_BYTES_PER_CHUNK + 1;
@@ -2289,14 +2887,14 @@ int yaffs_WriteDataToFile(yaffs_Object *in,const __u8 * buffer, __u32 offset, in
 			
 			chunkWritten = yaffs_WriteChunkDataToObject(in,chunk,localBuffer,nToWriteBack,0);
 			
-			T(("Write with readback to chunk %d %d\n",chunk,chunkWritten));
+			//T(("Write with readback to chunk %d %d\n",chunk,chunkWritten));
 			
 		}
 		else
 		{
 			// A full chunk. Write directly from the supplied buffer.
 			chunkWritten = yaffs_WriteChunkDataToObject(in,chunk,buffer,YAFFS_BYTES_PER_CHUNK,0);
-			T(("Write to chunk %d %d\n",chunk,chunkWritten));
+			//T(("Write to chunk %d %d\n",chunk,chunkWritten));
 		}
 		
 		if(chunkWritten >= 0)
@@ -2317,7 +2915,7 @@ int yaffs_WriteDataToFile(yaffs_Object *in,const __u8 * buffer, __u32 offset, in
 	}
 	
 	in->dirty = 1;
-	in->st_mtime = CURRENT_TIME;
+	/*in->st_mtime = CURRENT_TIME; only update in flush*/
 	
 	return nDone;
 }
@@ -2328,11 +2926,13 @@ int yaffs_ResizeFile(yaffs_Object *in, int newSize)
 	int i;
 	int chunkId;
 	int oldFileSize = in->variant.fileVariant.fileSize;
-	int sizeOfLastChunk = newSize % YAFFS_BYTES_PER_CHUNK;
+	int sizeOfPartialChunk = newSize % YAFFS_BYTES_PER_CHUNK;
 	
 	yaffs_Device *dev = in->myDev;
 	
 	__u8 localBuffer[YAFFS_BYTES_PER_CHUNK];
+
+	yaffs_INVALIDATECHUNKCACHE(in);
 	
 	if(in->variantType != YAFFS_OBJECT_TYPE_FILE)
 	{
@@ -2342,36 +2942,40 @@ int yaffs_ResizeFile(yaffs_Object *in, int newSize)
 	if(newSize < oldFileSize)
 	{
 		
-		int lastDel = 1 + oldFileSize/YAFFS_BYTES_PER_CHUNK;
+		int lastDel = 1 + (oldFileSize-1)/YAFFS_BYTES_PER_CHUNK;
 		
 		int startDel = 1 + (newSize + YAFFS_BYTES_PER_CHUNK - 1)/
 							YAFFS_BYTES_PER_CHUNK;
 
-		for(i = startDel; i <= lastDel; i++)
+		// Delete backwards so that we don't end up with holes if
+		// power is lost part-way through the operation.
+		for(i = lastDel; i >= startDel; i--)
 		{
 			// NB this could be optimised somewhat,
 			// eg. could retrieve the tags and write them without
 			// using yaffs_DeleteChunk
+
 			chunkId = yaffs_FindAndDeleteChunkInFile(in,i,NULL);
-			if(chunkId < 0 || chunkId >= (dev->endBlock * 32))
+			if(chunkId <= 0 || chunkId >= (dev->endBlock * 32))
 			{
-				T(("Found daft chunkId %d for %d\n",chunkId,i));
+				//T(("Found daft chunkId %d for %d\n",chunkId,i));
 			}
 			else
 			{
+				in->nDataChunks--;
 				yaffs_DeleteChunk(dev,chunkId);
 			}
 		}
 		
 		
-		if(sizeOfLastChunk != 0)
+		if(sizeOfPartialChunk != 0)
 		{
 			int lastChunk = 1+ newSize/YAFFS_BYTES_PER_CHUNK;
 			
 			// Got to read and rewrite the last chunk with its new size.
 			yaffs_ReadChunkDataFromObject(in,lastChunk,localBuffer);
 			
-			yaffs_WriteChunkDataToObject(in,lastChunk,localBuffer,sizeOfLastChunk,1);
+			yaffs_WriteChunkDataToObject(in,lastChunk,localBuffer,sizeOfPartialChunk,1);
 				
 		}
 		
@@ -2414,8 +3018,11 @@ int yaffs_FlushFile(yaffs_Object *in)
 	int retVal;
 	if(in->dirty)
 	{
-		T(("flushing object header\n"));
-		retVal = yaffs_UpdateObjectHeader(in,NULL);
+		//T(("flushing object header\n"));
+	
+		in->st_mtime = CURRENT_TIME;
+
+		retVal = yaffs_UpdateObjectHeader(in,NULL,0);
 	}
 	else
 	{
@@ -2429,8 +3036,16 @@ int yaffs_FlushFile(yaffs_Object *in)
 
 static int yaffs_DoGenericObjectDeletion(yaffs_Object *in)
 {
+	yaffs_INVALIDATECHUNKCACHE(in);
 	yaffs_RemoveObjectFromDirectory(in);
 	yaffs_DeleteChunk(in->myDev,in->chunkId);
+#if __KERNEL__
+	if(in->myInode)
+	{
+		in->myInode->u.generic_ip = NULL;
+		in->myInode = 0;
+	}
+#endif
 	yaffs_FreeObject(in);
 	return YAFFS_OK;
 
@@ -2439,13 +3054,47 @@ static int yaffs_DoGenericObjectDeletion(yaffs_Object *in)
 // yaffs_DeleteFile deletes the whole file data
 // and the inode associated with the file.
 // It does not delete the links associated with the file.
-static int yaffs_DeleteFile(yaffs_Object *in)
+static int yaffs_UnlinkFile(yaffs_Object *in)
 {
+
+#ifdef CONFIG_YAFFS_DISABLE_BACKGROUND_DELETION
 	// Delete the file data & tnodes
+#if 0
 	yaffs_ResizeFile(in,0);
+#else
+	 yaffs_DeleteWorker(in, in->variant.fileVariant.top, in->variant.fileVariant.topLevel, 0,NULL);
+
+#endif
+
 	yaffs_FreeTnode(in->myDev,in->variant.fileVariant.top);
 	
 	return  yaffs_DoGenericObjectDeletion(in);
+#else
+	int retVal;
+	retVal = yaffs_ChangeObjectName(in, in->myDev->unlinkedDir,NULL);
+	if(retVal == YAFFS_OK)
+	{
+		in->unlinked = 1;
+		in->renameAllowed = 0;
+	}
+	return retVal;
+
+	
+#endif
+}
+
+int yaffs_DeleteFile(yaffs_Object *in)
+{
+	int retVal = YAFFS_OK;
+	if(!in->unlinked)
+	{
+		retVal = yaffs_UnlinkFile(in);
+	}
+	if(retVal == YAFFS_OK && in->unlinked)
+	{
+		in->deleted = 1;
+	}
+	return in->deleted ? YAFFS_OK : YAFFS_FAIL;	
 }
 
 static int yaffs_DeleteDirectory(yaffs_Object *in)
@@ -2514,6 +3163,7 @@ static int yaffs_UnlinkWorker(yaffs_Object *obj)
 		hl->st_atime = obj->st_atime;
 		hl->st_mtime = obj->st_mtime;
 		hl->st_ctime = obj->st_ctime;
+		hl->st_rdev = obj->st_rdev;
 		
 		hl->variantType = obj->variantType;
 		
@@ -2521,6 +3171,7 @@ static int yaffs_UnlinkWorker(yaffs_Object *obj)
 		{
 			case YAFFS_OBJECT_TYPE_FILE:
 			case YAFFS_OBJECT_TYPE_SYMLINK:
+			case YAFFS_OBJECT_TYPE_SPECIAL:
 				// These types are OK to just copy across.
 				hl->variant = obj->variant;
 				break;
@@ -2557,7 +3208,7 @@ static int yaffs_UnlinkWorker(yaffs_Object *obj)
 		yaffs_HashObject(hl);
 		
 		// Update the hardlink which has become an object
-		yaffs_UpdateObjectHeader(hl,NULL);
+		yaffs_UpdateObjectHeader(hl,NULL,0);
 
 		// Finally throw away the deleted object
 		yaffs_DeleteChunk(obj->myDev,obj->chunkId);
@@ -2607,7 +3258,7 @@ static int yaffs_UnlinkWorker(yaffs_Object *obj)
 		switch(obj->variantType)
 		{
 			case YAFFS_OBJECT_TYPE_FILE:
-				return yaffs_DeleteFile(obj);
+				return yaffs_UnlinkFile(obj);
 				break;
 			case YAFFS_OBJECT_TYPE_DIRECTORY:
 				return yaffs_DeleteDirectory(obj);
@@ -2641,6 +3292,47 @@ int yaffs_Unlink(yaffs_Object *dir, const char *name)
 //////////////// Initialisation Scanning /////////////////
 
 
+
+// For now we use the SmartMedia check.
+// We look at the blockStatus byte in the first two chunks
+// These must be 0xFF to pass as OK.
+// todo: this function needs to be modifyable foir different NAND types
+// and different chunk sizes.  Suggest make this into a per-device configurable
+// function.
+static int yaffs_IsBlockBad(yaffs_Device *dev, int blk)
+{
+	yaffs_Spare spare;
+	
+	yaffs_ReadChunkFromNAND(dev,blk * YAFFS_CHUNKS_PER_BLOCK,NULL,&spare,1);
+#if 1
+	if(yaffs_CountBits(spare.blockStatus) < 7)
+	{
+		return 1;
+	}
+#else
+	if(spare.blockStatus != 0xFF)
+	{
+		return 1;
+	}
+#endif
+	yaffs_ReadChunkFromNAND(dev,blk * YAFFS_CHUNKS_PER_BLOCK + 1,NULL,&spare,1);
+
+#if 1
+	if(yaffs_CountBits(spare.blockStatus) < 7)
+	{
+		return 1;
+	}
+#else
+	if(spare.blockStatus != 0xFF)
+	{
+		return 1;
+	}
+#endif
+	
+	return 0;
+	
+}
+
 static int yaffs_Scan(yaffs_Device *dev)
 {
 	yaffs_Spare spare;
@@ -2652,9 +3344,8 @@ static int yaffs_Scan(yaffs_Device *dev)
 	yaffs_BlockState state;
 	yaffs_Object *hardList = NULL;
 	yaffs_Object *hl;
-	
-//	int inuse;
-//	__u32 pageBits;
+	yaffs_BlockInfo *bi;
+
 	
 	yaffs_ObjectHeader *oh;
 	yaffs_Object *in;
@@ -2668,10 +3359,18 @@ static int yaffs_Scan(yaffs_Device *dev)
 	for(blk = dev->startBlock; blk <= dev->endBlock; blk++)
 	{
 		deleted = 0;
-		dev->blockInfo[blk].pageBits = 0;
-		dev->blockInfo[blk].pagesInUse = 0;
+		bi = yaffs_GetBlockInfo(dev,blk);
+		bi->pageBits = 0;
+		bi->pagesInUse = 0;
 		state = YAFFS_BLOCK_STATE_SCANNING;
 		
+		
+		if(yaffs_IsBlockBad(dev,blk))
+		{
+			state = YAFFS_BLOCK_STATE_DEAD;
+			T((TSTR("block %d is bad" TENDSTR),blk));
+		}
+		
 		// Read each chunk in the block.
 		
 		for(c = 0; c < YAFFS_CHUNKS_PER_BLOCK && 
@@ -2680,160 +3379,190 @@ static int yaffs_Scan(yaffs_Device *dev)
 			// Read the spare area and decide what to do
 			chunk = blk * YAFFS_CHUNKS_PER_BLOCK + c;
 			
-			yaffs_ReadChunkFromNAND(dev,chunk,NULL,&spare);
+			yaffs_ReadChunkFromNAND(dev,chunk,NULL,&spare,1);
 
 			
-			// Is this a valid block?
-			if(yaffs_countBits[spare.blockStatus] >= 7)
+			// This block looks ok, now what's in this chunk?
+			yaffs_GetTagsFromSpare(&spare,&tags);
+			
+			if(yaffs_CountBits(spare.pageStatus) < 6)
+			{
+				// A deleted chunk
+				deleted++;
+				dev->nFreeChunks ++;
+				//T((" %d %d deleted\n",blk,c));
+			}
+			else if(tags.objectId == YAFFS_UNUSED_OBJECT_ID)
 			{
-				// This block looks ok, now what's in this chunk?
-				yaffs_GetTagsFromSpare(&spare,&tags);
+				// An unassigned chunk in the block
+				// This means that either the block is empty or 
+				// this is the one being allocated from
 				
-				if(yaffs_countBits[spare.pageStatus] < 6)
+				if(c == 0)
 				{
-					// A deleted chunk
-					deleted++;
-					dev->nFreeChunks ++;
-					T((" %d %d deleted\n",blk,c));
+					// the block is unused
+					state = YAFFS_BLOCK_STATE_EMPTY;
+					dev->nErasedBlocks++;
 				}
-				else if(tags.objectId == YAFFS_UNUSED_OBJECT_ID)
+				else
 				{
-					// An unassigned chunk in the block
-					// This means that either the block is empty or 
-					// this is the one being allocated from
+					// this is the block being allocated from
+					T((TSTR(" Allocating from %d %d" TENDSTR),blk,c));
+					state = YAFFS_BLOCK_STATE_ALLOCATING;
+					dev->allocationBlock = blk;
+					dev->allocationPage = c;
+				}
+
+				dev->nFreeChunks += (YAFFS_CHUNKS_PER_BLOCK - c);
+			}
+			else if(tags.chunkId > 0)
+			{
+				int endpos;
+				// A data chunk.
+				bi->pageBits |= (1 << c);
+				bi->pagesInUse++;
+								
+				in = yaffs_FindOrCreateObjectByNumber(dev,tags.objectId,YAFFS_OBJECT_TYPE_FILE);
+				// PutChunkIntoFIle checks for a clash (two data chunks with
+				// the same chunkId).
+				yaffs_PutChunkIntoFile(in,tags.chunkId,chunk,1);
+				endpos = (tags.chunkId - 1)* YAFFS_BYTES_PER_CHUNK + tags.byteCount;
+				if(in->variant.fileVariant.scannedFileSize <endpos)
+				{
+					in->variant.fileVariant.scannedFileSize = endpos;
+#ifndef CONFIG_YAFFS_USE_HEADER_FILE_SIZE
+						in->variant.fileVariant.fileSize = 	
+							in->variant.fileVariant.scannedFileSize;
+#endif
+
+				}
+				//T((" %d %d data %d %d\n",blk,c,tags.objectId,tags.chunkId));	
+			}
+			else
+			{
+				// chunkId == 0, so it is an ObjectHeader.
+				// Thus, we read in the object header and make the object
+				bi->pageBits |= (1 << c);
+				bi->pagesInUse++;
+							
+				yaffs_ReadChunkFromNAND(dev,chunk,chunkData,NULL,1);
+				
+				oh = (yaffs_ObjectHeader *)chunkData;
+				
+				in = yaffs_FindOrCreateObjectByNumber(dev,tags.objectId,oh->type);
+				
+				if(in->valid)
+				{
+					// We have already filled this one. We have a duplicate and need to resolve it.
 					
-					if(c == 0)
+					unsigned existingSerial = in->serial;
+					unsigned newSerial = tags.serialNumber;
+					
+					if(((existingSerial+1) & 3) == newSerial)
 					{
-						// the block is unused
-						state = YAFFS_BLOCK_STATE_EMPTY;
-						dev->nErasedBlocks++;
+						// Use new one - destroy the exisiting one
+						yaffs_DeleteChunk(dev,in->chunkId);
+						in->valid = 0;
 					}
 					else
 					{
-						// this is the block being allocated from
-						T((" allocating %d %d\n",blk,c));
-						state = YAFFS_BLOCK_STATE_ALLOCATING;
-						dev->allocationBlock = blk;
-						dev->allocationPage = c;
+						// Use existing - destroy this one.
+						yaffs_DeleteChunk(dev,chunk);
 					}
-
-					dev->nFreeChunks += (YAFFS_CHUNKS_PER_BLOCK - c);
 				}
-				else if(tags.chunkId > 0)
+				
+				if(!in->valid &&
+				   (tags.objectId == YAFFS_OBJECTID_ROOT ||
+				    tags.objectId == YAFFS_OBJECTID_LOSTNFOUND))
 				{
-					// A data chunk.
-					dev->blockInfo[blk].pageBits |= (1 << c);
-					dev->blockInfo[blk].pagesInUse++;
-									
-					in = yaffs_FindOrCreateObjectByNumber(dev,tags.objectId,YAFFS_OBJECT_TYPE_FILE);
-					// PutChunkIntoFIle checks for a clash (two data chunks with
-					// the same chunkId).
-					yaffs_PutChunkIntoFile(in,tags.chunkId,chunk,1);
-					T((" %d %d data %d %d\n",blk,c,tags.objectId,tags.chunkId));	
+					// We only load some info, don't fiddle with directory structure
+					in->valid = 1;
+					in->variantType = oh->type;
+	
+					in->st_mode  = oh->st_mode;
+					in->st_uid   = oh->st_uid;
+					in->st_gid   = oh->st_gid;
+					in->st_atime = oh->st_atime;
+					in->st_mtime = oh->st_mtime;
+					in->st_ctime = oh->st_ctime;
+					in->st_rdev = oh->st_rdev;
+					in->chunkId  = chunk;
+
 				}
-				else
+				else if(!in->valid)
 				{
-					// chunkId == 0, so it is an ObjectHeader.
-					// Thus, we read in the object header and make the object
-					dev->blockInfo[blk].pageBits |= (1 << c);
-					dev->blockInfo[blk].pagesInUse++;
-								
-					yaffs_ReadChunkFromNAND(dev,chunk,chunkData,NULL);
-					
-					oh = (yaffs_ObjectHeader *)chunkData;
-					
-					in = yaffs_FindOrCreateObjectByNumber(dev,tags.objectId,oh->type);
-					
-					if(in->valid)
+					// we need to load this info
+				
+					in->valid = 1;
+					in->variantType = oh->type;
+	
+					in->st_mode  = oh->st_mode;
+					in->st_uid   = oh->st_uid;
+					in->st_gid   = oh->st_gid;
+					in->st_atime = oh->st_atime;
+					in->st_mtime = oh->st_mtime;
+					in->st_ctime = oh->st_ctime;
+					in->st_rdev = oh->st_rdev;
+					in->chunkId  = chunk;
+
+					in->sum = oh->sum;
+					in->dirty = 0;
+							
+					// directory stuff...
+					// hook up to parent
+	
+					parent = yaffs_FindOrCreateObjectByNumber(dev,oh->parentObjectId,YAFFS_OBJECT_TYPE_DIRECTORY);
+					if(parent->variantType == YAFFS_OBJECT_TYPE_UNKNOWN)
 					{
-						// We have already filled this one. We have a duplicate and need to resolve it.
-						
-						unsigned existingSerial = in->serial;
-						unsigned newSerial = tags.serialNumber;
-						
-						if(((existingSerial+1) & 3) == newSerial)
-						{
-							// Use new one - destroy the exisiting one
-							yaffs_DeleteChunk(dev,in->chunkId);
-							in->valid = 0;
-						}
-						else
-						{
-							// Use existing - destroy this one.
-							yaffs_DeleteChunk(dev,chunk);
-						}
+						// Set up as a directory
+						parent->variantType = YAFFS_OBJECT_TYPE_DIRECTORY;
+						INIT_LIST_HEAD(&parent->variant.directoryVariant.children);
 					}
-					
-					if(!in->valid)
+					else if(parent->variantType != YAFFS_OBJECT_TYPE_DIRECTORY)
 					{
-						// we need to load this info
-					
-						in->valid = 1;
-						in->variantType = oh->type;
-		
-						in->st_mode  = oh->st_mode;
-						in->st_uid   = oh->st_uid;
-						in->st_gid   = oh->st_gid;
-						in->st_atime = oh->st_atime;
-						in->st_mtime = oh->st_mtime;
-						in->st_ctime = oh->st_ctime;
-						in->chunkId  = chunk;
-
-						in->sum = oh->sum;
-						in->dirty = 0;
-								
-						// directory stuff...
-						// hook up to parent
-		
-						parent = yaffs_FindOrCreateObjectByNumber(dev,oh->parentObjectId,YAFFS_OBJECT_TYPE_DIRECTORY);
-						if(parent->variantType == YAFFS_OBJECT_TYPE_UNKNOWN)
-						{
-							// Set up as a directory
-							parent->variantType = YAFFS_OBJECT_TYPE_DIRECTORY;
-							INIT_LIST_HEAD(&parent->variant.directoryVariant.children);
-						}
-						else if(parent->variantType != YAFFS_OBJECT_TYPE_DIRECTORY)
-						{
-							// Hoosterman, another problem....
-							// We're trying to use a non-directory as a directory
-							// Todo ... handle
-						}
-					
-						yaffs_AddObjectToDirectory(parent,in);	
-					
-						// Note re hardlinks.
-						// Since we might scan a hardlink before its equivalent object is scanned
-						// we put them all in a list.
-						// After scanning is complete, we should have all the objects, so we run through this
-						// list and fix up all the chains.		
-		
-						switch(in->variantType)
-						{
-							case YAFFS_OBJECT_TYPE_UNKNOWN: 	// Todo got a problem
-								break;
-							case YAFFS_OBJECT_TYPE_FILE:
-								in->variant.fileVariant.fileSize = oh->fileSize;
-								break;
-							case YAFFS_OBJECT_TYPE_HARDLINK:
-								in->variant.hardLinkVariant.equivalentObjectId = oh->equivalentObjectId;
-								(yaffs_Object *)(in->hardLinks.next) = hardList;
-								hardList = in;
-								break;
-							case YAFFS_OBJECT_TYPE_DIRECTORY:	// Do nothing
-								break;
-							case YAFFS_OBJECT_TYPE_SYMLINK: 	// Do nothing
-								in->variant.symLinkVariant.alias = yaffs_CloneString(oh->alias);
-								break;
-						}
-						T((" %d %d header %d \"%s\" type %d\n",blk,c,tags.objectId,oh->name,in->variantType));	
+						// Hoosterman, another problem....
+						// We're trying to use a non-directory as a directory
+						// Todo ... handle
+					}
+				
+					yaffs_AddObjectToDirectory(parent,in);
+					if(parent == dev->unlinkedDir)
+					{
+						in->deleted = 1; // If it is unlinked at start up then it wants deleting
+						dev->nDeletedFiles++;
 					}
+				
+					// Note re hardlinks.
+					// Since we might scan a hardlink before its equivalent object is scanned
+					// we put them all in a list.
+					// After scanning is complete, we should have all the objects, so we run through this
+					// list and fix up all the chains.		
+	
+					switch(in->variantType)
+					{
+						case YAFFS_OBJECT_TYPE_UNKNOWN: 	// Todo got a problem
+							break;
+						case YAFFS_OBJECT_TYPE_FILE:
+#ifdef CONFIG_YAFFS_USE_HEADER_FILE_SIZE
+							in->variant.fileVariant.fileSize = oh->fileSize;
+#endif
+							break;
+						case YAFFS_OBJECT_TYPE_HARDLINK:
+							in->variant.hardLinkVariant.equivalentObjectId = oh->equivalentObjectId;
+							(yaffs_Object *)(in->hardLinks.next) = hardList;
+							hardList = in;
+							break;
+						case YAFFS_OBJECT_TYPE_DIRECTORY:	// Do nothing
+							break;
+						case YAFFS_OBJECT_TYPE_SPECIAL:	// Do nothing
+							break;
+						case YAFFS_OBJECT_TYPE_SYMLINK: 	// Do nothing
+							in->variant.symLinkVariant.alias = yaffs_CloneString(oh->alias);
+							break;
+					}
+					//T((" %d %d header %d \"%s\" type %d\n",blk,c,tags.objectId,oh->name,in->variantType));	
 				}
 			}
-			else
-			{
-				// it's a bad block
-				state = YAFFS_BLOCK_STATE_DEAD;
-			}			
 		}
 		
 		if(state == YAFFS_BLOCK_STATE_SCANNING)
@@ -2842,11 +3571,11 @@ static int yaffs_Scan(yaffs_Device *dev)
 			state = YAFFS_BLOCK_STATE_FULL;	
 		}
 		
-		dev->blockInfo[blk].blockState = state;
+		bi->blockState = state;
 		
 		// Now let's see if it was dirty
-		if(	dev->blockInfo[blk].pagesInUse == 0 &&
-	        dev->blockInfo[blk].blockState == YAFFS_BLOCK_STATE_FULL)
+		if(	bi->pagesInUse == 0 &&
+	        bi->blockState == YAFFS_BLOCK_STATE_FULL)
 	    {
 	    	yaffs_BlockBecameDirty(dev,blk);
 	    }
@@ -2906,6 +3635,12 @@ static void yaffs_AddObjectToDirectory(yaffs_Object *directory, yaffs_Object *ob
 	// Now add it
 	list_add(&obj->siblings,&directory->variant.directoryVariant.children);
 	obj->parent = directory;
+	
+	if(directory == obj->myDev->unlinkedDir)
+	{
+		obj->unlinked = 1;
+		obj->renameAllowed = 0;
+	}
 }
 
 static void yaffs_RemoveObjectFromDirectory(yaffs_Object *obj)
@@ -2919,8 +3654,7 @@ yaffs_Object *yaffs_FindObjectByName(yaffs_Object *directory,const char *name)
 	int sum;
 	
 	struct list_head *i;
-	__u8 buffer[YAFFS_BYTES_PER_CHUNK];
-	yaffs_ObjectHeader *oh = (yaffs_ObjectHeader *)buffer;
+	char buffer[YAFFS_MAX_NAME_LENGTH+1];
 	
 	yaffs_Object *l;
 	
@@ -2933,16 +3667,16 @@ yaffs_Object *yaffs_FindObjectByName(yaffs_Object *directory,const char *name)
 		// Special case for lost-n-found
 		if(l->objectId == YAFFS_OBJECTID_LOSTNFOUND)
 		{
-			if(strcmp(name,YAFFS_LOSTNFOUND_NAME) == 0)
+			if(yaffs_strcmp(name,YAFFS_LOSTNFOUND_NAME) == 0)
 			{
 				return l;
 			}
 		}
-		else if(l->sum == sum)
+		else if(yaffs_SumCompare(l->sum, sum))
 		{
 			// Do a real check
-			yaffs_ReadChunkFromNAND(l->myDev,l->chunkId,buffer,NULL);
-			if(strcmp(name,oh->name) == 0)
+			yaffs_GetObjectName(l,buffer,YAFFS_MAX_NAME_LENGTH);
+			if(yaffs_strcmp(name,buffer) == 0)
 			{
 				return l;
 			}
@@ -2997,6 +3731,14 @@ int yaffs_GetObjectName(yaffs_Object *obj,char *name,int buffSize)
 	{
 		strncpy(name,YAFFS_LOSTNFOUND_NAME,buffSize - 1);
 	}
+	else if(obj->chunkId <= 0)
+	{
+		char locName[20];
+		// make up a name
+		sprintf(locName,"%s%d",YAFFS_LOSTNFOUND_PREFIX,obj->objectId);
+		strncpy(name,locName,buffSize - 1);
+
+	}
 	else
 	{
 		__u8 buffer[YAFFS_BYTES_PER_CHUNK];
@@ -3006,7 +3748,7 @@ int yaffs_GetObjectName(yaffs_Object *obj,char *name,int buffSize)
 	
 		if(obj->chunkId >= 0)
 		{
-			yaffs_ReadChunkFromNAND(obj->myDev,obj->chunkId,buffer,NULL);
+			yaffs_ReadChunkFromNAND(obj->myDev,obj->chunkId,buffer,NULL,1);
 		}
 		strncpy(name,oh->name,buffSize - 1);
 	}
@@ -3037,12 +3779,16 @@ int yaffs_GetObjectFileLength(yaffs_Object *obj)
 
 int yaffs_GetObjectLinkCount(yaffs_Object *obj)
 {
-	int count = 1; // the object itself
+	int count = 0; 
 	struct list_head *i;
 	
+	if(!obj->unlinked)
+	{
+		count++;	// the object itself
+	}
 	list_for_each(i,&obj->hardLinks)
 	{
-		count++;
+		count++;	// add the hard links;
 	}
 	return count;
 	
@@ -3066,6 +3812,11 @@ unsigned yaffs_GetObjectType(yaffs_Object *obj)
 		case YAFFS_OBJECT_TYPE_DIRECTORY:	return DT_DIR; break;
 		case YAFFS_OBJECT_TYPE_SYMLINK:		return DT_LNK; break;
 		case YAFFS_OBJECT_TYPE_HARDLINK:	return DT_REG; break;
+		case YAFFS_OBJECT_TYPE_SPECIAL:		
+			if(S_ISFIFO(obj->st_mode)) return DT_FIFO;
+			if(S_ISCHR(obj->st_mode)) return DT_CHR;
+			if(S_ISBLK(obj->st_mode)) return DT_BLK;
+			if(S_ISSOCK(obj->st_mode)) return DT_SOCK;
 		default: return DT_REG; break;
 	}
 }
@@ -3098,7 +3849,7 @@ int yaffs_SetAttributes(yaffs_Object *obj, struct iattr *attr)
 	
 	if(valid & ATTR_SIZE) yaffs_ResizeFile(obj,attr->ia_size);
 	
-	yaffs_UpdateObjectHeader(obj,NULL);
+	yaffs_UpdateObjectHeader(obj,NULL,1);
 	
 	return YAFFS_OK;
 	
@@ -3127,16 +3878,16 @@ int yaffs_GetAttributes(yaffs_Object *obj, struct iattr *attr)
 
 int yaffs_DumpObject(yaffs_Object *obj)
 {
-	__u8 buffer[YAFFS_BYTES_PER_CHUNK];
-	char name[256];
+//	__u8 buffer[YAFFS_BYTES_PER_CHUNK];
+	char name[257];
 //	yaffs_ObjectHeader *oh = (yaffs_ObjectHeader *)buffer;
 
-	memset(buffer,0,YAFFS_BYTES_PER_CHUNK);
+//	memset(buffer,0,YAFFS_BYTES_PER_CHUNK);
 	
-	if(obj->chunkId >= 0)
-	{
-		yaffs_ReadChunkFromNAND(obj->myDev,obj->chunkId,buffer,NULL);
-	}
+//	if(obj->chunkId >= 0)
+//	{
+//		yaffs_ReadChunkFromNAND(obj->myDev,obj->chunkId,buffer,NULL);
+//	}
 	
 	yaffs_GetObjectName(obj,name,256);
 	
@@ -3173,68 +3924,110 @@ int yaffs_DumpObject(yaffs_Object *obj)
 
 int yaffs_GutsInitialise(yaffs_Device *dev)
 {
-	unsigned  nChunks,x;
+	unsigned x;
 	int bits;
+	int extraBits;
+	int nBlocks;
 
 
-	dev = dev;
 	
 	if(!yaffs_CheckStructures())
 	{
+		YPRINTF(("yaffs_CheckStructures failed\n"));
 		return YAFFS_FAIL;
 	}
+	
+	if(dev->startBlock <= 0 ||
+	   (dev->endBlock - dev->startBlock) < 10)
+	{
+		YPRINTF(("startBlock %d or endBlock %d invalid\n",
+				dev->startBlock, dev->endBlock));
+		return YAFFS_FAIL;
+	}
+	
+	nBlocks = dev->endBlock - dev->startBlock + 1;
+	
 
 		
 	// OK now calculate a few things for the device
 	// Calculate chunkGroupBits. 
-	// If there are 64k or less chunks then this is 1
-	// Else it is log2(nChunks) - 16
-	//
-	x = nChunks = YAFFS_CHUNKS_PER_BLOCK * dev->nBlocks;
+	// We need to find the next power of 2 > than endBlock
+	
+	x = YAFFS_CHUNKS_PER_BLOCK * (dev->endBlock+1);
 	
-	for(bits = 0, x = nChunks; (x & 1) == 0; bits++)
+	for(bits = extraBits = 0; x > 1; bits++)
 	{
+		if(x & 1) extraBits++;
 		x >>= 1;
 	}
+
+	if(extraBits > 0) bits++;
 	
-	if( x != 1)
-	{
-		// Not a power of 2
-		YPRINTF(("nBlocks should be a power of 2 but is %u\n",
-			dev->nBlocks));
-		return YAFFS_FAIL;
-	}
 	
+	// Level0 Tnodes are 16 bits, so if the bitwidth of the
+	// chunk range we're using is greater than 16 we need 
+	// to figure out chunk shift and chunkGroupSize
 	if(bits <= 16) 
 	{
 		dev->chunkGroupBits = 0;
-		dev->chunkGroupSize = 1;
 	}
 	else
 	{
 		dev->chunkGroupBits = bits - 16;
-		dev->chunkGroupSize = nChunks/0x10000;
 	}
+	dev->chunkGroupSize = 1 << dev->chunkGroupBits;
+	
 	
 	// More device initialisation
 	dev->garbageCollectionRequired  = 0;
+	dev->garbageCollections = 0;
 	dev->currentDirtyChecker = 0;
+	dev->bufferedBlock = -1;
+	dev->doingBufferedBlockRewrite = 0;
+	dev->blockSelectedForGC = -1;
+	dev->nDeletedFiles = 0;
 	
-	yaffs_InitialiseBlocks(dev);
+	yaffs_InitialiseBlocks(dev,nBlocks);
 	
 	yaffs_InitialiseTnodes(dev);
 
 	yaffs_InitialiseObjects(dev);
 	
+#ifdef CONFIG_YAFFS_SHORT_OP_CACHE
+	{ 
+		int i;
+		for(i=0; i < YAFFS_N_CACHE_CHUNKS; i++)
+		{
+			dev->srCache[i].objectId = 0;
+			dev->srCache[i].lastUse = 0;
+		}
+		dev->srLastUse = 0;
+	}
+#endif
+
+	dev->cacheHits = 0;
+	
+	
+	// Initialise the unlinked, root and lost and found directories
+	dev->lostNFoundDir = dev->rootDir = dev->unlinkedDir = NULL;
 	
-	// Initialise the root and lost and found directories
-	dev->lostNFoundDir = dev->rootDir = NULL;
+	dev->unlinkedDir = yaffs_CreateFakeDirectory(dev,YAFFS_OBJECTID_UNLINKED, S_IFDIR);
+
 	dev->rootDir = yaffs_CreateFakeDirectory(dev,YAFFS_OBJECTID_ROOT,YAFFS_ROOT_MODE | S_IFDIR);
-	dev->lostNFoundDir = yaffs_CreateFakeDirectory(dev,YAFFS_OBJECTID_LOSTNFOUND,YAFFS_ROOT_MODE | S_IFDIR);
+	dev->lostNFoundDir = yaffs_CreateFakeDirectory(dev,YAFFS_OBJECTID_LOSTNFOUND,YAFFS_LOSTNFOUND_MODE | S_IFDIR);
 	yaffs_AddObjectToDirectory(dev->rootDir,dev->lostNFoundDir);
+	
 		
 	// Now scan the flash.	
 	yaffs_Scan(dev);
+	
+	// Zero out stats
+	dev->nPageReads = 0;
+    dev->nPageWrites =  0;
+	dev->nBlockErasures = 0;
+	dev->nGCCopies = 0;
+	dev->nRetriedWrites = 0;
+	dev->nRetiredBlocks = 0;
 
 	
 	return YAFFS_OK;
@@ -3252,6 +4045,22 @@ void yaffs_Deinitialise(yaffs_Device *dev)
 int  yaffs_GetNumberOfFreeChunks(yaffs_Device *dev)
 {
 	int nFree = dev->nFreeChunks - (YAFFS_CHUNKS_PER_BLOCK * YAFFS_RESERVED_BLOCKS);
+	
+	struct list_head *i;	
+	yaffs_Object *l;
+	
+	
+	// To the free chunks add the chunks that are in the deleted unlinked files.
+	list_for_each(i,&dev->unlinkedDir->variant.directoryVariant.children)
+	{
+		l = list_entry(i, yaffs_Object,siblings);
+		if(l->deleted)
+		{
+			nFree++;
+			nFree += l->nDataChunks;
+		}
+	}
+
 
 	return (nFree < 0) ? 0 : nFree;	
 	
@@ -3285,6 +4094,7 @@ void yaffs_GutsTest(yaffs_Device *dev)
 	if(yaffs_CheckStructures() != YAFFS_OK)
 	{
 		YPRINTF(("One or more structures malformed-- aborting\n"));
+		return;
 	}
 	else
 	{