From: charles <charles>
Date: Tue, 3 Oct 2006 10:13:03 +0000 (+0000)
Subject: Add large NAND support and improve retirement handling
X-Git-Tag: pre-name-change~341
X-Git-Url: http://www.aleph1.co.uk/gitweb/?p=yaffs2.git;a=commitdiff_plain;h=378bbdf4d64b8b26db55a495ab6ae520ff62e471

Add large NAND support and improve retirement handling
---

diff --git a/direct/Makefile b/direct/Makefile
index 47a25a9..e25fea4 100644
--- a/direct/Makefile
+++ b/direct/Makefile
@@ -10,11 +10,11 @@
 #
 # NB Warning this Makefile does not include header dependencies.
 #
-# $Id: Makefile,v 1.11 2006-09-21 08:13:59 charles Exp $
+# $Id: Makefile,v 1.12 2006-10-03 10:13:03 charles Exp $
 
 #EXTRA_COMPILE_FLAGS = -DYAFFS_IGNORE_TAGS_ECC
 
-CFLAGS =    -Wall -DCONFIG_YAFFS_DIRECT -DCONFIG_YAFFS_SHORT_NAMES_IN_RAM -DCONFIG_YAFFS_YAFFS2 -g $(EXTRA_COMPILE_FLAGS)
+CFLAGS =    -Wall -DCONFIG_YAFFS_DIRECT -DCONFIG_YAFFS_SHORT_NAMES_IN_RAM -DCONFIG_YAFFS_YAFFS2 -g $(EXTRA_COMPILE_FLAGS) -DNO_Y_INLINE
 #CFLAGS+=   -Wshadow -Wpointer-arith -Wwrite-strings -Wstrict-prototypes -Wmissing-declarations
 #CFLAGS+=   -Wmissing-prototypes -Wredundant-decls -Wnested-externs -Winline
 
diff --git a/direct/dtest.c b/direct/dtest.c
index 714cd0f..2bd26e5 100644
--- a/direct/dtest.c
+++ b/direct/dtest.c
@@ -166,6 +166,7 @@ void create_file_of_size(const char *fn,int syze)
 	int h;
 	int n;
 	
+	char xx[200];
 	
 	int iterations = (syze + strlen(fn) -1)/ strlen(fn);
 	
@@ -173,7 +174,37 @@ void create_file_of_size(const char *fn,int syze)
 		
 	while (iterations > 0)
 	{
-		yaffs_write(h,fn,strlen(fn));
+		sprintf(xx,"%s %8d",fn,iterations);
+		yaffs_write(h,xx,strlen(xx));
+		iterations--;
+	}
+	yaffs_close (h);
+}
+
+void verify_file_of_size(const char *fn,int syze)
+{
+	int h;
+	int n;
+	
+	char xx[200];
+	char yy[200];
+	int l;
+	
+	int iterations = (syze + strlen(fn) -1)/ strlen(fn);
+	
+	h = yaffs_open(fn, O_RDONLY, S_IREAD | S_IWRITE);
+		
+	while (iterations > 0)
+	{
+		sprintf(xx,"%s %8d",fn,iterations);
+		l = strlen(xx);
+		
+		yaffs_read(h,yy,l);
+		yy[l] = 0;
+		
+		if(strcmp(xx,yy)){
+			printf("=====>>>>> verification of file %s failed near position %d\n",fn,yaffs_lseek(h,0,SEEK_CUR));
+		}
 		iterations--;
 	}
 	yaffs_close (h);
@@ -1870,6 +1901,54 @@ void checkpoint_upgrade_test(const char *mountpt,int nmounts)
 	}
 }
 	
+void huge_array_test(const char *mountpt,int n)
+{
+
+	char a[50];
+
+	
+	int i;
+	int j;
+	int h;
+	
+	int fnum;
+	
+	sprintf(a,"mount point %s",mountpt);
+	
+
+	
+	yaffs_StartUp();
+
+	yaffs_mount(mountpt);
+	
+	while(n>0){
+		n--;
+		fnum = 0;
+		printf("\n\n START run\n\n");
+		while(yaffs_freespace(mountpt) > 25000000){
+			sprintf(a,"%s/file%d",mountpt,fnum);
+			fnum++;
+			printf("create file %s\n",a);
+			create_file_of_size(a,10000000);
+			printf("verifying file %s\n",a);
+			verify_file_of_size(a,10000000);
+		}
+		
+		printf("\n\n\ verification/deletion\n\n");
+		
+		for(i = 0; i < fnum; i++){
+			sprintf(a,"%s/file%d",mountpt,i);
+			printf("verifying file %s\n",a);
+			verify_file_of_size(a,10000000);
+			printf("deleting file %s\n",a);
+			yaffs_unlink(a);
+		}
+		printf("\n\n\ done \n\n");
+			
+		   
+	}
+}
+	
 
 
 int main(int argc, char *argv[])
@@ -1890,7 +1969,9 @@ int main(int argc, char *argv[])
 	//short_scan_test("/flash/flash",40000,200);
 	 //multi_mount_test("/flash/flash",20);
 	 //checkpoint_fill_test("/flash/flash",20);
-	 checkpoint_upgrade_test("/flash/flash",20);
+	 //checkpoint_upgrade_test("/flash/flash",20);
+	  huge_array_test("/flash/flash",2);
+
 
 
 	
diff --git a/direct/yaffs_fileem2k.c b/direct/yaffs_fileem2k.c
index 7e867f6..dcb3e5f 100644
--- a/direct/yaffs_fileem2k.c
+++ b/direct/yaffs_fileem2k.c
@@ -15,7 +15,7 @@
 // This provides a YAFFS nand emulation on a file for emulating 2kB pages.
 // THis is only intended as test code to test persistence etc.
 
-const char *yaffs_flashif_c_version = "$Id: yaffs_fileem2k.c,v 1.5 2006-09-21 08:13:59 charles Exp $";
+const char *yaffs_flashif_c_version = "$Id: yaffs_fileem2k.c,v 1.6 2006-10-03 10:13:03 charles Exp $";
 
 
 #include "yportenv.h"
@@ -47,9 +47,12 @@ typedef struct
 
 
 
+#define MAX_HANDLES 20
+#define BLOCKS_PER_HANDLE 8000
+
 typedef struct
 {
-	int handle;
+	int handle[MAX_HANDLES];
 	int nBlocks;
 } yflash_Device;
 
@@ -57,15 +60,52 @@ static yflash_Device filedisk;
 
 int yaffs_testPartialWrite = 0;
 
+
+static char *NToName(char *buf,int n)
+{
+	sprintf(buf,"emfile%d",n);
+	return buf;
+}
+
+static char dummyBuffer[BLOCK_SIZE];
+
+static int GetBlockFileHandle(int n)
+{
+	int h;
+	int requiredSize;
+	
+	char name[40];
+	NToName(name,n);
+	int fSize;
+	int i;
+	
+	h =  open(name, O_RDWR | O_CREAT, S_IREAD | S_IWRITE);
+	if(h >= 0){
+		fSize = lseek(h,0,SEEK_END);
+		requiredSize = BLOCKS_PER_HANDLE * BLOCK_SIZE;
+		if(fSize < requiredSize){
+		   for(i = 0; i < BLOCKS_PER_HANDLE; i++)
+		   	if(write(h,dummyBuffer,BLOCK_SIZE) != BLOCK_SIZE)
+				return -1;
+			
+		}
+	}
+	
+	return h;
+
+}
+
 static int  CheckInit(void)
 {
 	static int initialised = 0;
-	
+	int h;
 	int i;
 
 	
-	int fSize;
+	off_t fSize;
+	off_t requiredSize;
 	int written;
+	int blk;
 	
 	yflash_Page p;
 	
@@ -76,43 +116,17 @@ static int  CheckInit(void)
 
 	initialised = 1;
 	
+	memset(dummyBuffer,0xff,sizeof(dummyBuffer));
 	
-	filedisk.nBlocks = SIZE_IN_MB * BLOCKS_PER_MB;
-	
-	filedisk.handle = open("yaffsemfile2k", O_RDWR | O_CREAT, S_IREAD | S_IWRITE);
 	
-	if(filedisk.handle < 0)
-	{
-		perror("Failed to open yaffs emulation file");
-		return YAFFS_FAIL;
-	}
+	filedisk.nBlocks = SIZE_IN_MB * BLOCKS_PER_MB;
+
+	for(i = 0; i <  MAX_HANDLES; i++)
+		filedisk.handle[i] = -1;
 	
+	for(i = 0,blk = 0; blk < filedisk.nBlocks; blk+=BLOCKS_PER_HANDLE,i++)
+		filedisk.handle[i] = GetBlockFileHandle(i);
 	
-	fSize = lseek(filedisk.handle,0,SEEK_END);
-	
-	if(fSize < filedisk.nBlocks * BLOCK_SIZE)
-	{
-		printf("Creating yaffs emulation file\n");
-		
-		lseek(filedisk.handle,0,SEEK_SET);
-		
-		memset(&p,0xff,sizeof(yflash_Page));
-		
-		for(i = 0; i <  filedisk.nBlocks * BLOCK_SIZE; i+= PAGE_SIZE)
-		{
-			written = write(filedisk.handle,&p,sizeof(yflash_Page));
-			
-			if(written != sizeof(yflash_Page))
-			{
-				printf("Write failed\n");
-				return YAFFS_FAIL;
-			}
-		}		
-	}
-	else
-	{
-		filedisk.nBlocks = fSize/(BLOCK_SIZE);
-	}
 	
 	return 1;
 }
@@ -129,33 +143,38 @@ int yflash_WriteChunkWithTagsToNAND(yaffs_Device *dev,int chunkInNAND,const __u8
 {
 	int written;
 	int pos;
-
+	int h;
+	
 	CheckInit();
 	
 	
 	
 	if(data)
 	{
-		pos = chunkInNAND * PAGE_SIZE;
-		lseek(filedisk.handle,pos,SEEK_SET);
-		written = write(filedisk.handle,data,dev->nBytesPerChunk);
+		pos = (chunkInNAND % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE;
+		h = filedisk.handle[(chunkInNAND / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))];
+		
+		lseek(h,pos,SEEK_SET);
+		written = write(h,data,dev->nDataBytesPerChunk);
 		
 		if(yaffs_testPartialWrite){
-			close(filedisk.handle);
+			close(h);
 			exit(1);
 		}
 		
-		if(written != dev->nBytesPerChunk) return YAFFS_FAIL;
+		if(written != dev->nDataBytesPerChunk) return YAFFS_FAIL;
 	}
 	
 	if(tags)
 	{
-		pos = chunkInNAND * PAGE_SIZE + PAGE_DATA_SIZE;
-		lseek(filedisk.handle,pos,SEEK_SET);
+		pos = (chunkInNAND % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE + PAGE_DATA_SIZE ;
+		h = filedisk.handle[(chunkInNAND / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))];
+		
+		lseek(h,pos,SEEK_SET);
 		if( 0 && dev->isYaffs2)
 		{
 			
-			written = write(filedisk.handle,tags,sizeof(yaffs_ExtendedTags));
+			written = write(h,tags,sizeof(yaffs_ExtendedTags));
 			if(written != sizeof(yaffs_ExtendedTags)) return YAFFS_FAIL;
 		}
 		else
@@ -163,7 +182,7 @@ int yflash_WriteChunkWithTagsToNAND(yaffs_Device *dev,int chunkInNAND,const __u8
 			yaffs_PackedTags2 pt;
 			yaffs_PackTags2(&pt,tags);
 
-			written = write(filedisk.handle,&pt,sizeof(pt));
+			written = write(h,&pt,sizeof(pt));
 			if(written != sizeof(pt)) return YAFFS_FAIL;
 		}
 	}
@@ -173,25 +192,6 @@ int yflash_WriteChunkWithTagsToNAND(yaffs_Device *dev,int chunkInNAND,const __u8
 
 }
 
-int yflash_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo)
-{
-	int written;
-	
-	yaffs_PackedTags2 pt;
-
-	CheckInit();
-	
-	memset(&pt,0,sizeof(pt));
-	lseek(filedisk.handle,(blockNo * dev->nChunksPerBlock) * PAGE_SIZE + PAGE_DATA_SIZE,SEEK_SET);
-	written = write(filedisk.handle,&pt,sizeof(pt));
-		
-	if(written != sizeof(pt)) return YAFFS_FAIL;
-	
-	
-	return YAFFS_OK;
-	
-}
-
 int yaffs_CheckAllFF(const __u8 *ptr, int n)
 {
 	while(n)
@@ -208,27 +208,32 @@ int yflash_ReadChunkWithTagsFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *da
 {
 	int nread;
 	int pos;
-
+	int h;
+	
 	CheckInit();
 	
 	
 	
 	if(data)
 	{
-		pos = chunkInNAND * PAGE_SIZE;
-		lseek(filedisk.handle,pos,SEEK_SET);
-		nread = read(filedisk.handle,data,dev->nBytesPerChunk);
+
+		pos = (chunkInNAND % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE;
+		h = filedisk.handle[(chunkInNAND / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))];		
+		lseek(h,pos,SEEK_SET);
+		nread = read(h,data,dev->nDataBytesPerChunk);
 		
-		if(nread != dev->nBytesPerChunk) return YAFFS_FAIL;
+		if(nread != dev->nDataBytesPerChunk) return YAFFS_FAIL;
 	}
 	
 	if(tags)
 	{
-		pos = chunkInNAND * PAGE_SIZE + PAGE_DATA_SIZE;
-		lseek(filedisk.handle,pos,SEEK_SET);
+		pos = (chunkInNAND % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE + PAGE_DATA_SIZE;
+		h = filedisk.handle[(chunkInNAND / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))];		
+		lseek(h,pos,SEEK_SET);
+
 		if(0 && dev->isYaffs2)
 		{
-			nread= read(filedisk.handle,tags,sizeof(yaffs_ExtendedTags));
+			nread= read(h,tags,sizeof(yaffs_ExtendedTags));
 			if(nread != sizeof(yaffs_ExtendedTags)) return YAFFS_FAIL;
 			if(yaffs_CheckAllFF((__u8 *)tags,sizeof(yaffs_ExtendedTags)))
 			{
@@ -242,7 +247,7 @@ int yflash_ReadChunkWithTagsFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *da
 		else
 		{
 			yaffs_PackedTags2 pt;
-			nread= read(filedisk.handle,&pt,sizeof(pt));
+			nread= read(h,&pt,sizeof(pt));
 			yaffs_UnpackTags2(tags,&pt);
 			if(nread != sizeof(pt)) return YAFFS_FAIL;
 		}
@@ -254,10 +259,32 @@ int yflash_ReadChunkWithTagsFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *da
 }
 
 
+int yflash_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo)
+{
+	int written;
+	int h;
+	
+	yaffs_PackedTags2 pt;
+
+	CheckInit();
+	
+	memset(&pt,0,sizeof(pt));
+	h = filedisk.handle[(blockNo / ( BLOCKS_PER_HANDLE))];
+	lseek(h,((blockNo % BLOCKS_PER_HANDLE) * dev->nChunksPerBlock) * PAGE_SIZE + PAGE_DATA_SIZE,SEEK_SET);
+	written = write(h,&pt,sizeof(pt));
+		
+	if(written != sizeof(pt)) return YAFFS_FAIL;
+	
+	
+	return YAFFS_OK;
+	
+}
+
 int yflash_EraseBlockInNAND(yaffs_Device *dev, int blockNumber)
 {
 
 	int i;
+	int h;
 		
 	CheckInit();
 	
@@ -275,13 +302,14 @@ int yflash_EraseBlockInNAND(yaffs_Device *dev, int blockNumber)
 		
 		memset(pg,0xff,syz);
 		
-		pos = lseek(filedisk.handle, blockNumber * dev->nChunksPerBlock * PAGE_SIZE, SEEK_SET);
-		
+
+		h = filedisk.handle[(blockNumber / ( BLOCKS_PER_HANDLE))];
+		lseek(h,((blockNumber % BLOCKS_PER_HANDLE) * dev->nChunksPerBlock) * PAGE_SIZE,SEEK_SET);		
 		for(i = 0; i < dev->nChunksPerBlock; i++)
 		{
-			write(filedisk.handle,pg,PAGE_SIZE);
+			write(h,pg,PAGE_SIZE);
 		}
-		pos = lseek(filedisk.handle, 0,SEEK_CUR);
+		pos = lseek(h, 0,SEEK_CUR);
 		
 		return YAFFS_OK;
 	}
diff --git a/direct/yaffs_fileem2k.h b/direct/yaffs_fileem2k.h
index bf17f2c..aa8f661 100644
--- a/direct/yaffs_fileem2k.h
+++ b/direct/yaffs_fileem2k.h
@@ -17,7 +17,8 @@
 
 #if 1
 
-#define SIZE_IN_MB 512
+//#define SIZE_IN_MB 128
+#define SIZE_IN_MB 8000
 #define PAGE_DATA_SIZE (2048)
 #define PAGE_SPARE_SIZE  (64)
 #define PAGE_SIZE  (PAGE_DATA_SIZE + PAGE_SPARE_SIZE)
diff --git a/direct/yaffscfg2k.c b/direct/yaffscfg2k.c
index 849a56d..bf4f172 100644
--- a/direct/yaffscfg2k.c
+++ b/direct/yaffscfg2k.c
@@ -84,7 +84,7 @@ int yaffs_StartUp(void)
 	// Set up devices
 	// /ram
 	memset(&ramDev,0,sizeof(ramDev));
-	ramDev.nBytesPerChunk = 512;
+	ramDev.nDataBytesPerChunk = 512;
 	ramDev.nChunksPerBlock = 32;
 	ramDev.nReservedBlocks = 2; // Set this smaller for RAM
 	ramDev.startBlock = 0; // Can use block 0
@@ -99,7 +99,7 @@ int yaffs_StartUp(void)
 
 	// /boot
 	memset(&bootDev,0,sizeof(bootDev));
-	bootDev.nBytesPerChunk = 512;
+	bootDev.nDataBytesPerChunk = 512;
 	bootDev.nChunksPerBlock = 32;
 	bootDev.nReservedBlocks = 5;
 	bootDev.startBlock = 0; // Can use block 0
@@ -122,15 +122,15 @@ int yaffs_StartUp(void)
 	// 2kpage/64chunk per block/128MB device
 	memset(&flashDev,0,sizeof(flashDev));
 
-	flashDev.nBytesPerChunk = 2048;
+	flashDev.nDataBytesPerChunk = 2048;
 	flashDev.nChunksPerBlock = 64;
 	flashDev.nReservedBlocks = 5;
 	flashDev.nCheckpointReservedBlocks = 5;
 	//flashDev.checkpointStartBlock = 1;
 	//flashDev.checkpointEndBlock = 20;
 	flashDev.startBlock = 20; 
-	flashDev.endBlock = 127; // Make it smaller
-	//flashDev.endBlock = yflash_GetNumberOfBlocks()-1;
+	//flashDev.endBlock = 127; // Make it smaller
+	flashDev.endBlock = yflash_GetNumberOfBlocks()-1;
 	flashDev.isYaffs2 = 1;
 	flashDev.wideTnodesDisabled=0;
 	flashDev.nShortOpCaches = 10; // Use caches
@@ -148,7 +148,7 @@ int yaffs_StartUp(void)
 	// 2kpage/64chunk per block/128MB device
 	memset(&ram2kDev,0,sizeof(ram2kDev));
 
-	ram2kDev.nBytesPerChunk = nandemul2k_GetBytesPerChunk();
+	ram2kDev.nDataBytesPerChunk = nandemul2k_GetBytesPerChunk();
 	ram2kDev.nChunksPerBlock = nandemul2k_GetChunksPerBlock();
 	ram2kDev.nReservedBlocks = 5;
 	ram2kDev.startBlock = 0; // First block after /boot
diff --git a/direct/yaffsfs.c b/direct/yaffsfs.c
index 67671ea..9d7804c 100644
--- a/direct/yaffsfs.c
+++ b/direct/yaffsfs.c
@@ -25,7 +25,7 @@
 #endif
 
 
-const char *yaffsfs_c_version="$Id: yaffsfs.c,v 1.12 2006-05-08 10:13:35 charles Exp $";
+const char *yaffsfs_c_version="$Id: yaffsfs.c,v 1.13 2006-10-03 10:13:03 charles Exp $";
 
 // configurationList is the list of devices that are supported
 static yaffsfs_DeviceConfiguration *yaffsfs_configurationList;
@@ -620,7 +620,7 @@ int yaffs_write(int fd, const void *buf, unsigned int nbyte)
 
 }
 
-int yaffs_truncate(int fd, unsigned int newSize)
+int yaffs_truncate(int fd, off_t newSize)
 {
 	yaffsfs_Handle *h = NULL;
 	yaffs_Object *obj = NULL;
@@ -851,7 +851,7 @@ static int yaffsfs_DoStat(yaffs_Object *obj,struct yaffs_stat *buf)
     	buf->st_gid = 0;;     
     	buf->st_rdev = obj->yst_rdev;
     	buf->st_size = yaffs_GetObjectFileLength(obj);
-		buf->st_blksize = obj->myDev->nBytesPerChunk;
+		buf->st_blksize = obj->myDev->nDataBytesPerChunk;
     	buf->st_blocks = (buf->st_size + buf->st_blksize -1)/buf->st_blksize;
     	buf->yst_atime = obj->yst_atime; 
     	buf->yst_ctime = obj->yst_ctime; 
@@ -1118,9 +1118,9 @@ int yaffs_unmount(const char *path)
 	
 }
 
-off_t yaffs_freespace(const char *path)
+loff_t yaffs_freespace(const char *path)
 {
-	off_t retVal=-1;
+	loff_t retVal=-1;
 	yaffs_Device *dev=NULL;
 	char *dummy;
 	
@@ -1129,7 +1129,7 @@ off_t yaffs_freespace(const char *path)
 	if(dev  && dev->isMounted)
 	{
 		retVal = yaffs_GetNumberOfFreeChunks(dev);
-		retVal *= dev->nBytesPerChunk;
+		retVal *= dev->nDataBytesPerChunk;
 		
 	}
 	else
diff --git a/direct/yaffsfs.h b/direct/yaffsfs.h
index b670f11..0444d8f 100644
--- a/direct/yaffsfs.h
+++ b/direct/yaffsfs.h
@@ -177,7 +177,7 @@ int yaffs_read(int fd, void *buf, unsigned int nbyte) ;
 int yaffs_write(int fd, const void *buf, unsigned int nbyte) ;
 int yaffs_close(int fd) ;
 off_t yaffs_lseek(int fd, off_t offset, int whence) ;
-int yaffs_truncate(int fd, unsigned int newSize);
+int yaffs_truncate(int fd, off_t newSize);
 
 int yaffs_unlink(const char *path) ;
 int yaffs_rename(const char *oldPath, const char *newPath) ;
@@ -206,7 +206,7 @@ int yaffs_readlink(const char *path, char *buf, int bufsiz);
 int yaffs_link(const char *oldpath, const char *newpath); 
 int yaffs_mknod(const char *pathname, mode_t mode, dev_t dev);
 
-off_t yaffs_freespace(const char *path);
+loff_t yaffs_freespace(const char *path);
 
 void yaffs_initialise(yaffsfs_DeviceConfiguration *configList);
 
diff --git a/direct/ydirectenv.h b/direct/ydirectenv.h
index d059126..c651394 100644
--- a/direct/ydirectenv.h
+++ b/direct/ydirectenv.h
@@ -14,7 +14,7 @@
  *
  * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
  *
- * $Id: ydirectenv.h,v 1.3 2006-05-21 09:39:12 charles Exp $
+ * $Id: ydirectenv.h,v 1.4 2006-10-03 10:13:03 charles Exp $
  *
  */
  
@@ -38,8 +38,11 @@
 #define yaffs_sprintf	     sprintf
 #define yaffs_toupper(a)     toupper(a)
 
+#ifdef NO_Y_INLINE
+#define Y_INLINE
+#else
 #define Y_INLINE inline
-
+#endif
 
 #define YMALLOC(x) malloc(x)
 #define YFREE(x)   free(x)
diff --git a/yaffs_checkptrw.c b/yaffs_checkptrw.c
index 6ed976d..8d1bb66 100644
--- a/yaffs_checkptrw.c
+++ b/yaffs_checkptrw.c
@@ -13,7 +13,7 @@
  */
 
 const char *yaffs_checkptrw_c_version =
-    "$Id: yaffs_checkptrw.c,v 1.4 2006-05-23 19:08:41 charles Exp $";
+    "$Id: yaffs_checkptrw.c,v 1.5 2006-10-03 10:13:03 charles Exp $";
 
 
 #include "yaffs_checkptrw.h"
@@ -135,7 +135,7 @@ int yaffs_CheckpointOpen(yaffs_Device *dev, int forWriting)
 		return 0;
 			
 	if(!dev->checkpointBuffer)
-		dev->checkpointBuffer = YMALLOC_DMA(dev->nBytesPerChunk);
+		dev->checkpointBuffer = YMALLOC_DMA(dev->nDataBytesPerChunk);
 	if(!dev->checkpointBuffer)
 		return 0;
 
@@ -151,7 +151,7 @@ int yaffs_CheckpointOpen(yaffs_Device *dev, int forWriting)
 	
 	/* Erase all the blocks in the checkpoint area */
 	if(forWriting){
-		memset(dev->checkpointBuffer,0,dev->nBytesPerChunk);
+		memset(dev->checkpointBuffer,0,dev->nDataBytesPerChunk);
 		dev->checkpointByteOffset = 0;
 		return yaffs_CheckpointErase(dev);
 		
@@ -159,7 +159,7 @@ int yaffs_CheckpointOpen(yaffs_Device *dev, int forWriting)
 	} else {
 		int i;
 		/* Set to a value that will kick off a read */
-		dev->checkpointByteOffset = dev->nBytesPerChunk;
+		dev->checkpointByteOffset = dev->nDataBytesPerChunk;
 		/* A checkpoint block list of 1 checkpoint block per 16 block is (hopefully)
 		 * going to be way more than we need */
 		dev->blocksInCheckpoint = 0;
@@ -191,7 +191,7 @@ static int yaffs_CheckpointFlushBuffer(yaffs_Device *dev)
 	tags.objectId = dev->checkpointNextBlock; /* Hint to next place to look */
 	tags.chunkId = dev->checkpointPageSequence + 1;
 	tags.sequenceNumber =  YAFFS_SEQUENCE_CHECKPOINT_DATA;
-	tags.byteCount = dev->nBytesPerChunk;
+	tags.byteCount = dev->nDataBytesPerChunk;
 	if(dev->checkpointCurrentChunk == 0){
 		/* First chunk we write for the block? Set block state to
 		   checkpoint */
@@ -210,7 +210,7 @@ static int yaffs_CheckpointFlushBuffer(yaffs_Device *dev)
 		dev->checkpointCurrentChunk = 0;
 		dev->checkpointCurrentBlock = -1;
 	}
-	memset(dev->checkpointBuffer,0,dev->nBytesPerChunk);
+	memset(dev->checkpointBuffer,0,dev->nDataBytesPerChunk);
 	
 	return 1;
 }
@@ -241,7 +241,7 @@ int yaffs_CheckpointWrite(yaffs_Device *dev,const void *data, int nBytes)
 		
 		
 		if(dev->checkpointByteOffset < 0 ||
-		   dev->checkpointByteOffset >= dev->nBytesPerChunk) 
+		   dev->checkpointByteOffset >= dev->nDataBytesPerChunk) 
 			ok = yaffs_CheckpointFlushBuffer(dev);
 
 	}
@@ -267,7 +267,7 @@ int yaffs_CheckpointRead(yaffs_Device *dev, void *data, int nBytes)
 	
 	
 		if(dev->checkpointByteOffset < 0 ||
-		   dev->checkpointByteOffset >= dev->nBytesPerChunk) {
+		   dev->checkpointByteOffset >= dev->nDataBytesPerChunk) {
 		   
 		   	if(dev->checkpointCurrentBlock < 0){
 				yaffs_CheckpointFindNextCheckpointBlock(dev);
diff --git a/yaffs_fs.c b/yaffs_fs.c
index 30ac265..89fbcb7 100644
--- a/yaffs_fs.c
+++ b/yaffs_fs.c
@@ -31,7 +31,7 @@
  */
 
 const char *yaffs_fs_c_version =
-    "$Id: yaffs_fs.c,v 1.52 2006-09-26 13:28:13 vwool Exp $";
+    "$Id: yaffs_fs.c,v 1.53 2006-10-03 10:13:03 charles Exp $";
 extern const char *yaffs_guts_c_version;
 
 #include <linux/config.h>
@@ -1294,23 +1294,23 @@ static int yaffs_statfs(struct super_block *sb, struct statfs *buf)
 	buf->f_type = YAFFS_MAGIC;
 	buf->f_bsize = sb->s_blocksize;
 	buf->f_namelen = 255;
-	if (sb->s_blocksize > dev->nBytesPerChunk) {
+	if (sb->s_blocksize > dev->nDataBytesPerChunk) {
 
 		buf->f_blocks =
 		    (dev->endBlock - dev->startBlock +
 		     1) * dev->nChunksPerBlock / (sb->s_blocksize /
-						  dev->nBytesPerChunk);
+						  dev->nDataBytesPerChunk);
 		buf->f_bfree =
 		    yaffs_GetNumberOfFreeChunks(dev) / (sb->s_blocksize /
-							dev->nBytesPerChunk);
+							dev->nDataBytesPerChunk);
 	} else {
 
 		buf->f_blocks =
 		    (dev->endBlock - dev->startBlock +
-		     1) * dev->nChunksPerBlock * (dev->nBytesPerChunk /
+		     1) * dev->nChunksPerBlock * (dev->nDataBytesPerChunk /
 						  sb->s_blocksize);
 		buf->f_bfree =
-		    yaffs_GetNumberOfFreeChunks(dev) * (dev->nBytesPerChunk /
+		    yaffs_GetNumberOfFreeChunks(dev) * (dev->nDataBytesPerChunk /
 							sb->s_blocksize);
 	}
 	buf->f_files = 0;
@@ -1639,7 +1639,7 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion,
 	dev->startBlock = 0;
 	dev->endBlock = nBlocks - 1;
 	dev->nChunksPerBlock = YAFFS_CHUNKS_PER_BLOCK;
-	dev->nBytesPerChunk = YAFFS_BYTES_PER_CHUNK;
+	dev->nDataBytesPerChunk = YAFFS_BYTES_PER_CHUNK;
 	dev->nReservedBlocks = 5;
 	dev->nShortOpCaches = 10;	/* Enable short op caching */
 
@@ -1654,10 +1654,10 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion,
 		dev->spareBuffer = YMALLOC(mtd->oobsize);
 		dev->isYaffs2 = 1;
 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
-		dev->nBytesPerChunk = mtd->writesize;
+		dev->nDataBytesPerChunk = mtd->writesize;
 		dev->nChunksPerBlock = mtd->erasesize / mtd->writesize;
 #else
-		dev->nBytesPerChunk = mtd->oobblock;
+		dev->nDataBytesPerChunk = mtd->oobblock;
 		dev->nChunksPerBlock = mtd->erasesize / mtd->oobblock;
 #endif
 		nBlocks = mtd->size / mtd->erasesize;
diff --git a/yaffs_guts.c b/yaffs_guts.c
index 130cf7a..306b9b4 100644
--- a/yaffs_guts.c
+++ b/yaffs_guts.c
@@ -13,7 +13,7 @@
  */
 
 const char *yaffs_guts_c_version =
-    "$Id: yaffs_guts.c,v 1.38 2006-10-03 02:25:57 charles Exp $";
+    "$Id: yaffs_guts.c,v 1.39 2006-10-03 10:13:03 charles Exp $";
 
 #include "yportenv.h"
 
@@ -30,6 +30,7 @@ const char *yaffs_guts_c_version =
 #include "yaffs_checkptrw.h"
 
 #include "yaffs_nand.h"
+#include "yaffs_packedtags2.h"
 
 
 #ifdef CONFIG_YAFFS_WINCE
@@ -108,6 +109,75 @@ static void yaffs_InvalidateChunkCache(yaffs_Object * object, int chunkId);
 
 static void yaffs_InvalidateCheckpoint(yaffs_Device *dev);
 
+
+
+/* Function to calculate chunk and offset */
+
+static void yaffs_AddrToChunk(yaffs_Device *dev, loff_t addr, __u32 *chunk, __u32 *offset)
+{
+	if(dev->chunkShift){
+		/* Easy-peasy power of 2 case */
+		*chunk  = (__u32)(addr >> dev->chunkShift);
+		*offset = (__u32)(addr & dev->chunkMask);
+	}
+	else if(dev->crumbsPerChunk)
+	{
+		/* Case where we're using "crumbs" */
+		*offset = (__u32)(addr & dev->crumbMask);
+		addr >>= dev->crumbShift;
+		*chunk = ((__u32)addr)/dev->crumbsPerChunk;
+		*offset += ((addr - (*chunk * dev->crumbsPerChunk)) << dev->crumbShift);
+	}
+	else
+		YBUG();
+}
+
+/* Function to return the number of shifts for a power of 2 greater than or equal 
+ * to the given number
+ * Note we don't try to cater for all possible numbers and this does not have to
+ * be hellishly efficient.
+ */
+ 
+static __u32 ShiftsGE(__u32 x)
+{
+	int extraBits;
+	int nShifts;
+	
+	nShifts = extraBits = 0;
+	
+	while(x>1){
+		if(x & 1) extraBits++;
+		x>>=1;
+		nShifts++;
+	}
+
+	if(extraBits) 
+		nShifts++;
+		
+	return nShifts;
+}
+
+/* Function to return the number of shifts to get a 1 in bit 0
+ */
+ 
+static __u32 ShiftDiv(__u32 x)
+{
+	int nShifts;
+	
+	nShifts =  0;
+	
+	if(!x) return 0;
+	
+	while( !(x&1)){
+		x>>=1;
+		nShifts++;
+	}
+		
+	return nShifts;
+}
+
+
+
 /* 
  * Temporary buffer manipulations.
  */
@@ -143,7 +213,7 @@ static __u8 *yaffs_GetTempBuffer(yaffs_Device * dev, int lineNo)
 	 */
 
 	dev->unmanagedTempAllocations++;
-	return YMALLOC(dev->nBytesPerChunk);
+	return YMALLOC(dev->nDataBytesPerChunk);
 
 }
 
@@ -297,14 +367,15 @@ static int yaffs_CheckChunkErased(struct yaffs_DeviceStruct *dev,
 	int retval = YAFFS_OK;
 	__u8 *data = yaffs_GetTempBuffer(dev, __LINE__);
 	yaffs_ExtendedTags tags;
+	int result;
 
-	yaffs_ReadChunkWithTagsFromNAND(dev, chunkInNAND, data, &tags);
+	result = yaffs_ReadChunkWithTagsFromNAND(dev, chunkInNAND, data, &tags);
 	
 	if(tags.eccResult > YAFFS_ECC_RESULT_NO_ERROR)
 		retval = YAFFS_FAIL;
 		
 
-	if (!yaffs_CheckFF(data, dev->nBytesPerChunk) || tags.chunkUsed) {
+	if (!yaffs_CheckFF(data, dev->nDataBytesPerChunk) || tags.chunkUsed) {
 		T(YAFFS_TRACE_NANDACCESS,
 		  (TSTR("Chunk %d not erased" TENDSTR), chunkInNAND));
 		retval = YAFFS_FAIL;
@@ -343,7 +414,7 @@ static int yaffs_WriteNewChunkWithTagsToNAND(struct yaffs_DeviceStruct *dev,
 			 *
 			 * However, if the block has been prioritised for gc, then
 			 * we think there might be something odd about this block
-			 * and should continue doing erased checks.
+			 * and stop using it.
 			 *
 			 * Rationale:
 			 * We should only ever see chunks that have not been erased
@@ -353,39 +424,45 @@ static int yaffs_WriteNewChunkWithTagsToNAND(struct yaffs_DeviceStruct *dev,
 			 * needed.
 			 */
 			 
+			 if(bi->gcPrioritise){
+			 		yaffs_DeleteChunk(dev, chunk, 1, __LINE__);
+			} else {
 #ifdef CONFIG_YAFFS_ALWAYS_CHECK_CHUNK_ERASED
-			bi->skipErasedCheck = 0;
+
+				bi->skipErasedCheck = 0;
+
 #endif
-			if(!bi->skipErasedCheck){
-				erasedOk = yaffs_CheckChunkErased(dev, chunk);
-				if(erasedOk && !bi->gcPrioritise)
-					bi->skipErasedCheck = 1;
-			}
+				if(!bi->skipErasedCheck){
+					erasedOk = yaffs_CheckChunkErased(dev, chunk);
+					if(erasedOk && !bi->gcPrioritise)
+						bi->skipErasedCheck = 1;
+				}
 
-			if (!erasedOk) {
-				T(YAFFS_TRACE_ERROR,
-				  (TSTR
-				   ("**>> yaffs chunk %d was not erased"
-				    TENDSTR), chunk));
-			} else {
-				writeOk =
-				    yaffs_WriteChunkWithTagsToNAND(dev, chunk,
-								   data, tags);
-			}
+				if (!erasedOk) {
+					T(YAFFS_TRACE_ERROR,
+					  (TSTR
+					   ("**>> yaffs chunk %d was not erased"
+					    TENDSTR), chunk));
+				} else {
+					writeOk =
+					    yaffs_WriteChunkWithTagsToNAND(dev, chunk,
+									   data, tags);
+				}
 			
-			attempts++;
+				attempts++;
 
-			if (writeOk) {
-				/*
-				 *  Copy the data into the robustification buffer.
-				 *  NB We do this at the end to prevent duplicates in the case of a write error.
-				 *  Todo
-				 */
-				yaffs_HandleWriteChunkOk(dev, chunk, data, tags);
+				if (writeOk) {
+					/*
+					 *  Copy the data into the robustification buffer.
+					 *  NB We do this at the end to prevent duplicates in the case of a write error.
+					 *  Todo
+					 */
+					yaffs_HandleWriteChunkOk(dev, chunk, data, tags);
 				
-			} else {
-				/* The erased check or write failed */
-				yaffs_HandleWriteChunkError(dev, chunk, erasedOk);
+				} else {
+					/* The erased check or write failed */
+					yaffs_HandleWriteChunkError(dev, chunk, erasedOk);
+				}
 			}
 		}
 
@@ -439,7 +516,9 @@ static void yaffs_HandleWriteChunkError(yaffs_Device * dev, int chunkInNAND, int
 
 	int blockInNAND = chunkInNAND / dev->nChunksPerBlock;
 	yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, blockInNAND);
+		
 	bi->gcPrioritise = 1;
+	dev->hasPendingPrioritisedGCs = 1;
 	
 	if(erasedOk) {
 		/* Was an actual write failure, so mark the block for retirement  */
@@ -1933,9 +2012,27 @@ static int yaffs_FindBlockForGarbageCollection(yaffs_Device * dev,
 	int iterations;
 	int dirtiest = -1;
 	int pagesInUse;
-	int prioritised;
+	int prioritised=0;
 	yaffs_BlockInfo *bi;
 	static int nonAggressiveSkip = 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++){
+
+			bi = yaffs_GetBlockInfo(dev, i);
+			if(bi->blockState == YAFFS_BLOCK_STATE_FULL &&
+			   bi->gcPrioritise &&
+			   yaffs_BlockNotDisqualifiedFromGC(dev, bi)){
+				pagesInUse = (bi->pagesInUse - bi->softDeletions);
+				dirtiest = b;
+				prioritised = 1;
+				aggressive = 1; /* Fool the non-aggressive skip logiv below */
+			}
+		}
+		if(dirtiest < 0) /* 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.
@@ -1949,8 +2046,9 @@ static int yaffs_FindBlockForGarbageCollection(yaffs_Device * dev,
 		return -1;
 	}
 
-	pagesInUse =
-	    (aggressive) ? dev->nChunksPerBlock : YAFFS_PASSIVE_GC_CHUNKS + 1;
+	if(!prioritised)
+		pagesInUse =
+	    		(aggressive) ? dev->nChunksPerBlock : YAFFS_PASSIVE_GC_CHUNKS + 1;
 
 	if (aggressive) {
 		iterations =
@@ -1964,7 +2062,7 @@ static int yaffs_FindBlockForGarbageCollection(yaffs_Device * dev,
 		}
 	}
 
-	for (i = 0, prioritised = 0; i <= iterations && pagesInUse > 0 && !prioritised; i++) {
+	for (i = 0; i <= iterations && pagesInUse > 0 && !prioritised; i++) {
 		b++;
 		if (b < dev->internalStartBlock || b > dev->internalEndBlock) {
 			b = dev->internalStartBlock;
@@ -1987,12 +2085,10 @@ static int yaffs_FindBlockForGarbageCollection(yaffs_Device * dev,
 #endif
 
 		if (bi->blockState == YAFFS_BLOCK_STATE_FULL &&
-		      (bi->gcPrioritise || (bi->pagesInUse - bi->softDeletions)) < pagesInUse &&
+		       (bi->pagesInUse - bi->softDeletions) < pagesInUse &&
 		        yaffs_BlockNotDisqualifiedFromGC(dev, bi)) {
 			dirtiest = b;
 			pagesInUse = (bi->pagesInUse - bi->softDeletions);
-			if(bi->gcPrioritise)
-				prioritised = 1; /* Trick it into selecting this one */
 		}
 	}
 
@@ -2580,7 +2676,7 @@ static int yaffs_CheckFileSanity(yaffs_Object * in)
 	objId = in->objectId;
 	fSize = in->variant.fileVariant.fileSize;
 	nChunks =
-	    (fSize + in->myDev->nBytesPerChunk - 1) / in->myDev->nBytesPerChunk;
+	    (fSize + in->myDev->nDataBytesPerChunk - 1) / in->myDev->nDataBytesPerChunk;
 
 	for (chunk = 1; chunk <= nChunks; chunk++) {
 		tn = yaffs_FindLevel0Tnode(in->myDev, &in->variant.fileVariant,
@@ -2747,13 +2843,13 @@ static int yaffs_ReadChunkDataFromObject(yaffs_Object * in, int chunkInInode,
 
 	if (chunkInNAND >= 0) {
 		return yaffs_ReadChunkWithTagsFromNAND(in->myDev, chunkInNAND,
-						       buffer, NULL);
+						       buffer,NULL);
 	} else {
 		T(YAFFS_TRACE_NANDACCESS,
 		  (TSTR("Chunk %d not found zero instead" TENDSTR),
 		   chunkInNAND));
 		/* get sane (zero) data if you read a hole */
-		memset(buffer, 0, in->myDev->nBytesPerChunk);	
+		memset(buffer, 0, in->myDev->nDataBytesPerChunk);	
 		return 0;
 	}
 
@@ -2879,6 +2975,7 @@ int yaffs_UpdateObjectHeader(yaffs_Object * in, const YCHAR * name, int force,
 
 	int prevChunkId;
 	int retVal = 0;
+	int result = 0;
 
 	int newChunkId;
 	yaffs_ExtendedTags newTags;
@@ -2898,12 +2995,12 @@ int yaffs_UpdateObjectHeader(yaffs_Object * in, const YCHAR * name, int force,
 		prevChunkId = in->chunkId;
 
 		if (prevChunkId >= 0) {
-			yaffs_ReadChunkWithTagsFromNAND(dev, prevChunkId,
+			result = yaffs_ReadChunkWithTagsFromNAND(dev, prevChunkId,
 							buffer, NULL);
 			memcpy(oldName, oh->name, sizeof(oh->name));
 		}
 
-		memset(buffer, 0xFF, dev->nBytesPerChunk);
+		memset(buffer, 0xFF, dev->nDataBytesPerChunk);
 
 		oh->type = in->variantType;
 		oh->yst_mode = in->yst_mode;
@@ -3043,12 +3140,11 @@ static int yaffs_ObjectHasCachedWriteData(yaffs_Object *obj)
 	yaffs_ChunkCache *cache;
 	int nCaches = obj->myDev->nShortOpCaches;
 	
-	if(nCaches > 0){
-		for(i = 0; i < nCaches; i++){
-			if (dev->srCache[i].object == obj &&
-				    dev->srCache[i].dirty)
-				    	return 1;
-		}
+	for(i = 0; i < nCaches; i++){
+		cache = &dev->srCache[i];
+		if (cache->object == obj &&
+		    cache->dirty)
+			return 1;
 	}
 	
 	return 0;
@@ -3761,7 +3857,7 @@ int yaffs_CheckpointRestore(yaffs_Device *dev)
  * Curve-balls: the first chunk might also be the last chunk.
  */
 
-int yaffs_ReadDataFromFile(yaffs_Object * in, __u8 * buffer, __u32 offset,
+int yaffs_ReadDataFromFile(yaffs_Object * in, __u8 * buffer, loff_t offset,
 			   int nBytes)
 {
 
@@ -3777,16 +3873,18 @@ int yaffs_ReadDataFromFile(yaffs_Object * in, __u8 * buffer, __u32 offset,
 	dev = in->myDev;
 
 	while (n > 0) {
-		chunk = offset / dev->nBytesPerChunk + 1;   /* The first chunk is 1 */
-		start = offset % dev->nBytesPerChunk;
+		//chunk = offset / dev->nDataBytesPerChunk + 1;
+		//start = offset % dev->nDataBytesPerChunk;
+		yaffs_AddrToChunk(dev,offset,&chunk,&start);
+		chunk++;
 
 		/* OK now check for the curveball where the start and end are in
 		 * the same chunk.      
 		 */
-		if ((start + n) < dev->nBytesPerChunk) {
+		if ((start + n) < dev->nDataBytesPerChunk) {
 			nToCopy = n;
 		} else {
-			nToCopy = dev->nBytesPerChunk - start;
+			nToCopy = dev->nDataBytesPerChunk - start;
 		}
 
 		cache = yaffs_FindChunkCache(in, chunk);
@@ -3795,7 +3893,7 @@ int yaffs_ReadDataFromFile(yaffs_Object * in, __u8 * buffer, __u32 offset,
 		 * then use the cache (if there is caching)
 		 * else bypass the cache.
 		 */
-		if (cache || nToCopy != dev->nBytesPerChunk) {
+		if (cache || nToCopy != dev->nDataBytesPerChunk) {
 			if (dev->nShortOpCaches > 0) {
 
 				/* If we can't find the data in the cache, then load it up. */
@@ -3856,7 +3954,7 @@ int yaffs_ReadDataFromFile(yaffs_Object * in, __u8 * buffer, __u32 offset,
 #ifdef CONFIG_YAFFS_WINCE
 			yfsd_UnlockYAFFS(TRUE);
 #endif
-			memcpy(buffer, localBuffer, dev->nBytesPerChunk);
+			memcpy(buffer, localBuffer, dev->nDataBytesPerChunk);
 
 #ifdef CONFIG_YAFFS_WINCE
 			yfsd_LockYAFFS(TRUE);
@@ -3879,7 +3977,7 @@ int yaffs_ReadDataFromFile(yaffs_Object * in, __u8 * buffer, __u32 offset,
 	return nDone;
 }
 
-int yaffs_WriteDataToFile(yaffs_Object * in, const __u8 * buffer, __u32 offset,
+int yaffs_WriteDataToFile(yaffs_Object * in, const __u8 * buffer, loff_t offset,
 			  int nBytes, int writeThrough)
 {
 
@@ -3898,14 +3996,16 @@ int yaffs_WriteDataToFile(yaffs_Object * in, const __u8 * buffer, __u32 offset,
 	dev = in->myDev;
 
 	while (n > 0 && chunkWritten >= 0) {
-		chunk = offset / dev->nBytesPerChunk + 1;
-		start = offset % dev->nBytesPerChunk;
+		//chunk = offset / dev->nDataBytesPerChunk + 1;
+		//start = offset % dev->nDataBytesPerChunk;
+		yaffs_AddrToChunk(dev,offset,&chunk,&start);
+		chunk++;
 
 		/* OK now check for the curveball where the start and end are in
 		 * the same chunk.
 		 */
 
-		if ((start + n) < dev->nBytesPerChunk) {
+		if ((start + n) < dev->nDataBytesPerChunk) {
 			nToCopy = n;
 
 			/* Now folks, to calculate how many bytes to write back....
@@ -3915,10 +4015,10 @@ int yaffs_WriteDataToFile(yaffs_Object * in, const __u8 * buffer, __u32 offset,
 
 			nBytesRead =
 			    in->variant.fileVariant.fileSize -
-			    ((chunk - 1) * dev->nBytesPerChunk);
+			    ((chunk - 1) * dev->nDataBytesPerChunk);
 
-			if (nBytesRead > dev->nBytesPerChunk) {
-				nBytesRead = dev->nBytesPerChunk;
+			if (nBytesRead > dev->nDataBytesPerChunk) {
+				nBytesRead = dev->nDataBytesPerChunk;
 			}
 
 			nToWriteBack =
@@ -3926,11 +4026,11 @@ int yaffs_WriteDataToFile(yaffs_Object * in, const __u8 * buffer, __u32 offset,
 			     (start + n)) ? nBytesRead : (start + n);
 
 		} else {
-			nToCopy = dev->nBytesPerChunk - start;
-			nToWriteBack = dev->nBytesPerChunk;
+			nToCopy = dev->nDataBytesPerChunk - start;
+			nToWriteBack = dev->nDataBytesPerChunk;
 		}
 
-		if (nToCopy != dev->nBytesPerChunk) {
+		if (nToCopy != dev->nDataBytesPerChunk) {
 			/* An incomplete start or end chunk (or maybe both start and end chunk) */
 			if (dev->nShortOpCaches > 0) {
 				yaffs_ChunkCache *cache;
@@ -4028,20 +4128,20 @@ int yaffs_WriteDataToFile(yaffs_Object * in, const __u8 * buffer, __u32 offset,
 #ifdef CONFIG_YAFFS_WINCE
 			yfsd_UnlockYAFFS(TRUE);
 #endif
-			memcpy(localBuffer, buffer, dev->nBytesPerChunk);
+			memcpy(localBuffer, buffer, dev->nDataBytesPerChunk);
 #ifdef CONFIG_YAFFS_WINCE
 			yfsd_LockYAFFS(TRUE);
 #endif
 			chunkWritten =
 			    yaffs_WriteChunkDataToObject(in, chunk, localBuffer,
-							 dev->nBytesPerChunk,
+							 dev->nDataBytesPerChunk,
 							 0);
 			yaffs_ReleaseTempBuffer(dev, localBuffer, __LINE__);
 #else
 			/* A full chunk. Write directly from the supplied buffer. */
 			chunkWritten =
 			    yaffs_WriteChunkDataToObject(in, chunk, buffer,
-							 dev->nBytesPerChunk,
+							 dev->nDataBytesPerChunk,
 							 0);
 #endif
 			/* Since we've overwritten the cached data, we better invalidate it. */
@@ -4077,10 +4177,10 @@ static void yaffs_PruneResizedChunks(yaffs_Object * in, int newSize)
 	yaffs_Device *dev = in->myDev;
 	int oldFileSize = in->variant.fileVariant.fileSize;
 
-	int lastDel = 1 + (oldFileSize - 1) / dev->nBytesPerChunk;
+	int lastDel = 1 + (oldFileSize - 1) / dev->nDataBytesPerChunk;
 
-	int startDel = 1 + (newSize + dev->nBytesPerChunk - 1) /
-	    dev->nBytesPerChunk;
+	int startDel = 1 + (newSize + dev->nDataBytesPerChunk - 1) /
+	    dev->nDataBytesPerChunk;
 	int i;
 	int chunkId;
 
@@ -4112,14 +4212,16 @@ static void yaffs_PruneResizedChunks(yaffs_Object * in, int newSize)
 
 }
 
-int yaffs_ResizeFile(yaffs_Object * in, int newSize)
+int yaffs_ResizeFile(yaffs_Object * in, loff_t newSize)
 {
 
 	int oldFileSize = in->variant.fileVariant.fileSize;
-	int sizeOfPartialChunk;
+	int newSizeOfPartialChunk;
+	int newFullChunks;
+	
 	yaffs_Device *dev = in->myDev;
-
-	sizeOfPartialChunk = newSize % dev->nBytesPerChunk;
+	
+	yaffs_AddrToChunk(dev, newSize, &newFullChunks, &newSizeOfPartialChunk);
 
 	yaffs_FlushFilesChunkCache(in);
 	yaffs_InvalidateWholeChunkCache(in);
@@ -4138,19 +4240,20 @@ int yaffs_ResizeFile(yaffs_Object * in, int newSize)
 
 		yaffs_PruneResizedChunks(in, newSize);
 
-		if (sizeOfPartialChunk != 0) {
-			int lastChunk = 1 + newSize / dev->nBytesPerChunk;
+		if (newSizeOfPartialChunk != 0) {
+			int lastChunk = 1 + newFullChunks;
+			
 			__u8 *localBuffer = yaffs_GetTempBuffer(dev, __LINE__);
 
 			/* Got to read and rewrite the last chunk with its new size and zero pad */
 			yaffs_ReadChunkDataFromObject(in, lastChunk,
 						      localBuffer);
 
-			memset(localBuffer + sizeOfPartialChunk, 0,
-			       dev->nBytesPerChunk - sizeOfPartialChunk);
+			memset(localBuffer + newSizeOfPartialChunk, 0,
+			       dev->nDataBytesPerChunk - newSizeOfPartialChunk);
 
 			yaffs_WriteChunkDataToObject(in, lastChunk, localBuffer,
-						     sizeOfPartialChunk, 1);
+						     newSizeOfPartialChunk, 1);
 
 			yaffs_ReleaseTempBuffer(dev, localBuffer, __LINE__);
 		}
@@ -4527,6 +4630,7 @@ static int yaffs_Scan(yaffs_Device * dev)
 	int startIterator;
 	int endIterator;
 	int nBlocksToScan = 0;
+	int result;
 
 	int chunk;
 	int c;
@@ -4665,7 +4769,7 @@ static int yaffs_Scan(yaffs_Device * dev)
 			/* Read the tags and decide what to do */
 			chunk = blk * dev->nChunksPerBlock + c;
 
-			yaffs_ReadChunkWithTagsFromNAND(dev, chunk, NULL,
+			result = yaffs_ReadChunkWithTagsFromNAND(dev, chunk, NULL,
 							&tags);
 
 			/* Let's have a good look at this chunk... */
@@ -4731,7 +4835,7 @@ static int yaffs_Scan(yaffs_Device * dev)
 				yaffs_PutChunkIntoFile(in, tags.chunkId, chunk,
 						       1);
 				endpos =
-				    (tags.chunkId - 1) * dev->nBytesPerChunk +
+				    (tags.chunkId - 1) * dev->nDataBytesPerChunk +
 				    tags.byteCount;
 				if (in->variantType == YAFFS_OBJECT_TYPE_FILE
 				    && in->variant.fileVariant.scannedFileSize <
@@ -4754,7 +4858,7 @@ static int yaffs_Scan(yaffs_Device * dev)
 				yaffs_SetChunkBit(dev, blk, c);
 				bi->pagesInUse++;
 
-				yaffs_ReadChunkWithTagsFromNAND(dev, chunk,
+				result = yaffs_ReadChunkWithTagsFromNAND(dev, chunk,
 								chunkData,
 								NULL);
 
@@ -5014,12 +5118,14 @@ static void yaffs_CheckObjectDetailsLoaded(yaffs_Object *in)
 	__u8 *chunkData;
 	yaffs_ObjectHeader *oh;
 	yaffs_Device *dev = in->myDev;
+	yaffs_ExtendedTags tags;
+	int result;
 	
 	if(in->lazyLoaded){
 		in->lazyLoaded = 0;
 		chunkData = yaffs_GetTempBuffer(dev, __LINE__);
 
-		yaffs_ReadChunkWithTagsFromNAND(dev,in->chunkId,chunkData,NULL);
+		result = yaffs_ReadChunkWithTagsFromNAND(dev,in->chunkId,chunkData,&tags);
 		oh = (yaffs_ObjectHeader *) chunkData;		
 
 		in->yst_mode = oh->yst_mode;
@@ -5059,6 +5165,7 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
 	int nBlocksToScan = 0;
 
 	int chunk;
+	int result;
 	int c;
 	int deleted;
 	yaffs_BlockState state;
@@ -5233,7 +5340,7 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
 			 */
 			chunk = blk * dev->nChunksPerBlock + c;
 
-			yaffs_ReadChunkWithTagsFromNAND(dev, chunk, NULL,
+			result = yaffs_ReadChunkWithTagsFromNAND(dev, chunk, NULL,
 							&tags);
 
 			/* Let's have a good look at this chunk... */
@@ -5294,7 +5401,7 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
 				/* chunkId > 0 so it is a data chunk... */
 				unsigned int endpos;
 				__u32 chunkBase =
-				    (tags.chunkId - 1) * dev->nBytesPerChunk;
+				    (tags.chunkId - 1) * dev->nDataBytesPerChunk;
 								
 				foundChunksInBlock = 1;
 
@@ -5318,7 +5425,7 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
 					 */
 					endpos =
 					    (tags.chunkId -
-					     1) * dev->nBytesPerChunk +
+					     1) * dev->nDataBytesPerChunk +
 					    tags.byteCount;
 					    
 					if (!in->valid &&	/* have not got an object header yet */
@@ -5370,7 +5477,7 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
 					 * living with invalid data until needed.
 					 */
 
-					yaffs_ReadChunkWithTagsFromNAND(dev,
+					result = yaffs_ReadChunkWithTagsFromNAND(dev,
 									chunk,
 									chunkData,
 									NULL);
@@ -5882,14 +5989,15 @@ int yaffs_GetObjectName(yaffs_Object * obj, YCHAR * name, int buffSize)
 	}
 #endif
 	else {
+		int result;
 		__u8 *buffer = yaffs_GetTempBuffer(obj->myDev, __LINE__);
 
 		yaffs_ObjectHeader *oh = (yaffs_ObjectHeader *) buffer;
 
-		memset(buffer, 0, obj->myDev->nBytesPerChunk);
+		memset(buffer, 0, obj->myDev->nDataBytesPerChunk);
 
 		if (obj->chunkId >= 0) {
-			yaffs_ReadChunkWithTagsFromNAND(obj->myDev,
+			result = yaffs_ReadChunkWithTagsFromNAND(obj->myDev,
 							obj->chunkId, buffer,
 							NULL);
 		}
@@ -5914,7 +6022,7 @@ int yaffs_GetObjectFileLength(yaffs_Object * obj)
 		return yaffs_strlen(obj->variant.symLinkVariant.alias);
 	} else {
 		/* Only a directory should drop through to here */
-		return obj->myDev->nBytesPerChunk;
+		return obj->myDev->nDataBytesPerChunk;
 	}
 }
 
@@ -6116,7 +6224,6 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
 {
 	unsigned x;
 	int bits;
-	int extraBits;
 
 	T(YAFFS_TRACE_TRACING, (TSTR("yaffs: yaffs_GutsInitialise()" TENDSTR)));
 
@@ -6142,8 +6249,8 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
 
 	/* Check geometry parameters. */
 
-	if ((dev->isYaffs2 && dev->nBytesPerChunk < 1024) || 
-	    (!dev->isYaffs2 && dev->nBytesPerChunk != 512) || 
+	if ((dev->isYaffs2 && dev->nDataBytesPerChunk < 1024) || 
+	    (!dev->isYaffs2 && dev->nDataBytesPerChunk != 512) || 
 	     dev->nChunksPerBlock < 2 || 
 	     dev->nReservedBlocks < 2 || 
 	     dev->internalStartBlock <= 0 || 
@@ -6153,7 +6260,7 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
 		T(YAFFS_TRACE_ALWAYS,
 		  (TSTR
 		   ("yaffs: NAND geometry problems: chunk size %d, type is yaffs%s "
-		    TENDSTR), dev->nBytesPerChunk, dev->isYaffs2 ? "2" : ""));
+		    TENDSTR), dev->nDataBytesPerChunk, dev->isYaffs2 ? "2" : ""));
 		return YAFFS_FAIL;
 	}
 
@@ -6192,21 +6299,38 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
 
 
 
-	/* OK now calculate a few things for the device
+	/* OK now calculate a few things for the device */
+	
+	/*
+	 *  Calculate all the chunk size manipulation numbers: 
+	 */
+	 /* Start off assuming it is a power of 2 */
+	 dev->chunkShift = ShiftDiv(dev->nDataBytesPerChunk);
+	 dev->chunkMask = (1<<dev->chunkShift) - 1;
+
+	 if(dev->nDataBytesPerChunk == (dev->chunkMask + 1)){
+	 	/* Yes it is a power of 2, disable crumbs */
+		dev->crumbMask = 0;
+		dev->crumbShift = 0;
+		dev->crumbsPerChunk = 0;
+	 } else {
+	 	/* Not a power of 2, use crumbs instead */
+		dev->crumbShift = ShiftDiv(sizeof(yaffs_PackedTags2TagsPart));
+		dev->crumbMask = (1<<dev->crumbShift)-1;
+		dev->crumbsPerChunk = dev->nDataBytesPerChunk/(1 << dev->crumbShift);
+		dev->chunkShift = 0;
+		dev->chunkMask = 0;
+	}
+	 	
+
+	/*
 	 * Calculate chunkGroupBits.
 	 * We need to find the next power of 2 > than internalEndBlock
 	 */
 
 	x = dev->nChunksPerBlock * (dev->internalEndBlock + 1);
-
-	for (bits = extraBits = 0; x > 1; bits++) {
-		if (x & 1)
-			extraBits++;
-		x >>= 1;
-	}
-
-	if (extraBits > 0)
-		bits++;
+	
+	bits = ShiftsGE(x);
 	
 	/* Set up tnode width if wide tnodes are enabled. */
 	if(!dev->wideTnodesDisabled){
@@ -6266,6 +6390,7 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
 	dev->nErasureFailures = 0;
 	dev->nErasedBlocks = 0;
 	dev->isDoingGC = 0;
+	dev->hasPendingPrioritisedGCs = 1; /* Assume the worst for now, will get fixed on first GC */
 
 	/* Initialise temporary buffers and caches. */
 	{
@@ -6273,7 +6398,7 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
 		for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) {
 			dev->tempBuffer[i].line = 0;	/* not in use */
 			dev->tempBuffer[i].buffer =
-			    YMALLOC_DMA(dev->nBytesPerChunk);
+			    YMALLOC_DMA(dev->nDataBytesPerChunk);
 		}
 	}
 	
@@ -6291,7 +6416,7 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
 			dev->srCache[i].object = NULL;
 			dev->srCache[i].lastUse = 0;
 			dev->srCache[i].dirty = 0;
-			dev->srCache[i].data = YMALLOC_DMA(dev->nBytesPerChunk);
+			dev->srCache[i].data = YMALLOC_DMA(dev->nDataBytesPerChunk);
 		}
 		dev->srLastUse = 0;
 	}
diff --git a/yaffs_guts.h b/yaffs_guts.h
index e66efcf..cb9a8e0 100644
--- a/yaffs_guts.h
+++ b/yaffs_guts.h
@@ -14,7 +14,7 @@
  *
  * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
  *
- * $Id: yaffs_guts.h,v 1.23 2006-09-21 08:13:59 charles Exp $
+ * $Id: yaffs_guts.h,v 1.24 2006-10-03 10:13:03 charles Exp $
  */
 
 #ifndef __YAFFS_GUTS_H__
@@ -524,7 +524,7 @@ struct yaffs_DeviceStruct {
 	const char *name;
 
 	/* Entry parameters set up way early. Yaffs sets up the rest.*/
-	int nBytesPerChunk;	/* Should be a power of 2 >= 512 */
+	int nDataBytesPerChunk;	/* Should be a power of 2 >= 512 */
 	int nChunksPerBlock;	/* does not need to be a power of 2 */
 	int nBytesPerSpare;	/* spare area size */
 	int startBlock;		/* Start block we're allowed to use */
@@ -606,6 +606,16 @@ struct yaffs_DeviceStruct {
 	__u32 tnodeWidth;
 	__u32 tnodeMask;
 	
+	/* Stuff to support various file offses to chunk/offset translations */
+	/* "Crumbs" for nDataBytesPerChunk not being a power of 2 */
+	__u32 crumbMask;
+	__u32 crumbShift;
+	__u32 crumbsPerChunk;
+	
+	/* Straight shifting for nDataBytesPerChunk being a power of 2 */
+	__u32 chunkShift;
+	__u32 chunkMask;
+	
 
 #ifdef __KERNEL__
 
@@ -621,6 +631,7 @@ struct yaffs_DeviceStruct {
 	
 	int isCheckpointed;
 
+
 	/* Stuff to support block offsetting to support start block zero */
 	int internalStartBlock;
 	int internalEndBlock;
@@ -693,6 +704,8 @@ struct yaffs_DeviceStruct {
 	int tagsEccUnfixed;
 	int nDeletions;
 	int nUnmarkedDeletions;
+	
+	int hasPendingPrioritisedGCs; /* We think this device might have pending prioritised gcs */
 
 	/* Special directories */
 	yaffs_Object *rootDir;
@@ -808,11 +821,11 @@ int yaffs_SetAttributes(yaffs_Object * obj, struct iattr *attr);
 int yaffs_GetAttributes(yaffs_Object * obj, struct iattr *attr);
 
 /* File operations */
-int yaffs_ReadDataFromFile(yaffs_Object * obj, __u8 * buffer, __u32 offset,
+int yaffs_ReadDataFromFile(yaffs_Object * obj, __u8 * buffer, loff_t offset,
 			   int nBytes);
-int yaffs_WriteDataToFile(yaffs_Object * obj, const __u8 * buffer, __u32 offset,
+int yaffs_WriteDataToFile(yaffs_Object * obj, const __u8 * buffer, loff_t offset,
 			  int nBytes, int writeThrough);
-int yaffs_ResizeFile(yaffs_Object * obj, int newSize);
+int yaffs_ResizeFile(yaffs_Object * obj, loff_t newSize);
 
 yaffs_Object *yaffs_MknodFile(yaffs_Object * parent, const YCHAR * name,
 			      __u32 mode, __u32 uid, __u32 gid);
diff --git a/yaffs_mtdif.c b/yaffs_mtdif.c
index 1f40e8f..1e09650 100644
--- a/yaffs_mtdif.c
+++ b/yaffs_mtdif.c
@@ -14,7 +14,7 @@
  */
 
 const char *yaffs_mtdif_c_version =
-    "$Id: yaffs_mtdif.c,v 1.14 2006-09-26 13:28:13 vwool Exp $";
+    "$Id: yaffs_mtdif.c,v 1.15 2006-10-03 10:13:03 charles Exp $";
 
 #include "yportenv.h"
 
@@ -81,7 +81,7 @@ int nandmtd_WriteChunkToNAND(yaffs_Device * dev, int chunkInNAND,
 	size_t dummy;
 	int retval = 0;
 
-	loff_t addr = ((loff_t) chunkInNAND) * dev->nBytesPerChunk;
+	loff_t addr = ((loff_t) chunkInNAND) * dev->nDataBytesPerChunk;
 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
 	__u8 spareAsBytes[8]; /* OOB */
 
@@ -109,18 +109,18 @@ int nandmtd_WriteChunkToNAND(yaffs_Device * dev, int chunkInNAND,
 	if (data && spare) {
 		if (dev->useNANDECC)
 			retval =
-			    mtd->write_ecc(mtd, addr, dev->nBytesPerChunk,
+			    mtd->write_ecc(mtd, addr, dev->nDataBytesPerChunk,
 					   &dummy, data, spareAsBytes,
 					   &yaffs_oobinfo);
 		else
 			retval =
-			    mtd->write_ecc(mtd, addr, dev->nBytesPerChunk,
+			    mtd->write_ecc(mtd, addr, dev->nDataBytesPerChunk,
 					   &dummy, data, spareAsBytes,
 					   &yaffs_noeccinfo);
 	} else {
 		if (data)
 			retval =
-			    mtd->write(mtd, addr, dev->nBytesPerChunk, &dummy,
+			    mtd->write(mtd, addr, dev->nDataBytesPerChunk, &dummy,
 				       data);
 		if (spare)
 			retval =
@@ -145,7 +145,7 @@ int nandmtd_ReadChunkFromNAND(yaffs_Device * dev, int chunkInNAND, __u8 * data,
 	size_t dummy;
 	int retval = 0;
 
-	loff_t addr = ((loff_t) chunkInNAND) * dev->nBytesPerChunk;
+	loff_t addr = ((loff_t) chunkInNAND) * dev->nDataBytesPerChunk;
 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
 	__u8 spareAsBytes[8]; /* OOB */
 
@@ -178,19 +178,19 @@ int nandmtd_ReadChunkFromNAND(yaffs_Device * dev, int chunkInNAND, __u8 * data,
 			/* should allocate enough memory for spare, */
 			/* i.e. [YAFFS_BYTES_PER_SPARE+2*sizeof(int)]. */
 			retval =
-			    mtd->read_ecc(mtd, addr, dev->nBytesPerChunk,
+			    mtd->read_ecc(mtd, addr, dev->nDataBytesPerChunk,
 					  &dummy, data, spareAsBytes,
 					  &yaffs_oobinfo);
 		} else {
 			retval =
-			    mtd->read_ecc(mtd, addr, dev->nBytesPerChunk,
+			    mtd->read_ecc(mtd, addr, dev->nDataBytesPerChunk,
 					  &dummy, data, spareAsBytes,
 					  &yaffs_noeccinfo);
 		}
 	} else {
 		if (data)
 			retval =
-			    mtd->read(mtd, addr, dev->nBytesPerChunk, &dummy,
+			    mtd->read(mtd, addr, dev->nDataBytesPerChunk, &dummy,
 				      data);
 		if (spare)
 			retval =
@@ -209,14 +209,14 @@ int nandmtd_EraseBlockInNAND(yaffs_Device * dev, int blockNumber)
 {
 	struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
 	__u32 addr =
-	    ((loff_t) blockNumber) * dev->nBytesPerChunk
+	    ((loff_t) blockNumber) * dev->nDataBytesPerChunk
 		* dev->nChunksPerBlock;
 	struct erase_info ei;
 	int retval = 0;
 
 	ei.mtd = mtd;
 	ei.addr = addr;
-	ei.len = dev->nBytesPerChunk * dev->nChunksPerBlock;
+	ei.len = dev->nDataBytesPerChunk * dev->nChunksPerBlock;
 	ei.time = 1000;
 	ei.retries = 2;
 	ei.callback = NULL;
diff --git a/yaffs_mtdif2.c b/yaffs_mtdif2.c
index b7c973e..2c47951 100644
--- a/yaffs_mtdif2.c
+++ b/yaffs_mtdif2.c
@@ -16,7 +16,7 @@
 /* mtd interface for YAFFS2 */
 
 const char *yaffs_mtdif2_c_version =
-    "$Id: yaffs_mtdif2.c,v 1.13 2006-09-26 13:28:13 vwool Exp $";
+    "$Id: yaffs_mtdif2.c,v 1.14 2006-10-03 10:13:03 charles Exp $";
 
 #include "yportenv.h"
 
@@ -41,7 +41,7 @@ int nandmtd2_WriteChunkWithTagsToNAND(yaffs_Device * dev, int chunkInNAND,
 #endif
 	int retval = 0;
 
-	loff_t addr = ((loff_t) chunkInNAND) * dev->nBytesPerChunk;
+	loff_t addr = ((loff_t) chunkInNAND) * dev->nDataBytesPerChunk;
 
 	yaffs_PackedTags2 pt;
 
@@ -74,16 +74,16 @@ int nandmtd2_WriteChunkWithTagsToNAND(yaffs_Device * dev, int chunkInNAND,
 	if (data && tags) {
 		if (dev->useNANDECC)
 			retval =
-			    mtd->write_ecc(mtd, addr, dev->nBytesPerChunk,
+			    mtd->write_ecc(mtd, addr, dev->nDataBytesPerChunk,
 					   &dummy, data, (__u8 *) & pt, NULL);
 		else
 			retval =
-			    mtd->write_ecc(mtd, addr, dev->nBytesPerChunk,
+			    mtd->write_ecc(mtd, addr, dev->nDataBytesPerChunk,
 					   &dummy, data, (__u8 *) & pt, NULL);
 	} else {
 		if (data)
 			retval =
-			    mtd->write(mtd, addr, dev->nBytesPerChunk, &dummy,
+			    mtd->write(mtd, addr, dev->nDataBytesPerChunk, &dummy,
 				       data);
 		if (tags)
 			retval =
@@ -109,7 +109,7 @@ int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND,
 	size_t dummy;
 	int retval = 0;
 
-	loff_t addr = ((loff_t) chunkInNAND) * dev->nBytesPerChunk;
+	loff_t addr = ((loff_t) chunkInNAND) * dev->nDataBytesPerChunk;
 
 	yaffs_PackedTags2 pt;
 
@@ -135,19 +135,19 @@ int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND,
 	if (data && tags) {
 		if (dev->useNANDECC) {
 			retval =
-			    mtd->read_ecc(mtd, addr, dev->nBytesPerChunk,
+			    mtd->read_ecc(mtd, addr, dev->nDataBytesPerChunk,
 					  &dummy, data, dev->spareBuffer,
 					  NULL);
 		} else {
 			retval =
-			    mtd->read_ecc(mtd, addr, dev->nBytesPerChunk,
+			    mtd->read_ecc(mtd, addr, dev->nDataBytesPerChunk,
 					  &dummy, data, dev->spareBuffer,
 					  NULL);
 		}
 	} else {
 		if (data)
 			retval =
-			    mtd->read(mtd, addr, dev->nBytesPerChunk, &dummy,
+			    mtd->read(mtd, addr, dev->nDataBytesPerChunk, &dummy,
 				      data);
 		if (tags)
 			retval =
@@ -180,7 +180,7 @@ int nandmtd2_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo)
 	retval =
 	    mtd->block_markbad(mtd,
 			       blockNo * dev->nChunksPerBlock *
-			       dev->nBytesPerChunk);
+			       dev->nDataBytesPerChunk);
 
 	if (retval == 0)
 		return YAFFS_OK;
@@ -200,7 +200,7 @@ int nandmtd2_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo,
 	retval =
 	    mtd->block_isbad(mtd,
 			     blockNo * dev->nChunksPerBlock *
-			     dev->nBytesPerChunk);
+			     dev->nDataBytesPerChunk);
 
 	if (retval) {
 		T(YAFFS_TRACE_MTD, (TSTR("block is bad" TENDSTR)));
diff --git a/yaffs_nand.c b/yaffs_nand.c
index 989e8d9..26acf20 100644
--- a/yaffs_nand.c
+++ b/yaffs_nand.c
@@ -13,7 +13,7 @@
  */
  
 const char *yaffs_nand_c_version =
-    "$Id: yaffs_nand.c,v 1.2 2006-09-21 08:13:59 charles Exp $";
+    "$Id: yaffs_nand.c,v 1.3 2006-10-03 10:13:03 charles Exp $";
 
 #include "yaffs_nand.h"
 #include "yaffs_tagscompat.h"
@@ -25,8 +25,13 @@ int yaffs_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND,
 					   yaffs_ExtendedTags * tags)
 {
 	int result;
+	yaffs_ExtendedTags localTags;
 	
 	int realignedChunkInNAND = chunkInNAND - dev->chunkOffset;
+	
+	/* If there are no tags provided, use local tags to get prioritised gc working */
+	if(!tags)
+		tags = &localTags;
 
 	if (dev->readChunkWithTagsFromNAND)
 		result = dev->readChunkWithTagsFromNAND(dev, realignedChunkInNAND, buffer,
@@ -41,6 +46,7 @@ int yaffs_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND,
 	
 		yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, chunkInNAND/dev->nChunksPerBlock);
 		bi->gcPrioritise = 1;
+		dev->hasPendingPrioritisedGCs = 1;
 	}
 								
 	return result;