Mercurial > yaffs-ecoscentric

changeset 152:3bc7020d669c

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Add large NAND support and improve retirement handling
author charles
date Tue, 03 Oct 2006 11:13:03 +0100
parents b9ba4e46d2e5
children 0e41be657b37
files direct/Makefile direct/dtest.c direct/yaffs_fileem2k.c direct/yaffs_fileem2k.h direct/yaffscfg2k.c direct/yaffsfs.c direct/yaffsfs.h direct/ydirectenv.h yaffs_checkptrw.c yaffs_fs.c yaffs_guts.c yaffs_guts.h yaffs_mtdif.c yaffs_mtdif2.c yaffs_nand.c
diffstat 15 files changed, 507 insertions(+), 250 deletions(-) [+]
line wrap: on
line diff
--- a/direct/Makefile
+++ b/direct/Makefile
@@ -14,7 +14,7 @@
 
 #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
 
--- a/direct/dtest.c
+++ b/direct/dtest.c
@@ -166,6 +166,7 @@ void create_file_of_size(const char *fn,
 	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,
 		
 	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 
 	}
 }
 	
+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);
+
 
 
 	
--- a/direct/yaffs_fileem2k.c
+++ b/direct/yaffs_fileem2k.c
@@ -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;
 	
-	
-	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;
-	}
+	memset(dummyBuffer,0xff,sizeof(dummyBuffer));
 	
 	
-	fSize = lseek(filedisk.handle,0,SEEK_END);
+	filedisk.nBlocks = SIZE_IN_MB * BLOCKS_PER_MB;
+
+	for(i = 0; i <  MAX_HANDLES; i++)
+		filedisk.handle[i] = -1;
 	
-	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);
-	}
+	for(i = 0,blk = 0; blk < filedisk.nBlocks; blk+=BLOCKS_PER_HANDLE,i++)
+		filedisk.handle[i] = GetBlockFileHandle(i);
+	
 	
 	return 1;
 }
@@ -129,33 +143,38 @@ int yflash_WriteChunkWithTagsToNAND(yaff
 {
 	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(yaff
 			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(yaff
 
 }
 
-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(yaf
 {
 	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(yaf
 		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(yaf
 }
 
 
+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
 		
 		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;
 	}
--- 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)
--- 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
--- a/direct/yaffsfs.c
+++ b/direct/yaffsfs.c
@@ -620,7 +620,7 @@ int yaffs_write(int fd, const void *buf,
 
 }
 
-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 *
     	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
--- a/direct/yaffsfs.h
+++ b/direct/yaffsfs.h
@@ -177,7 +177,7 @@ int yaffs_read(int fd, void *buf, unsign
 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, cha
 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);
 
--- a/direct/ydirectenv.h
+++ b/direct/ydirectenv.h
@@ -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)
--- a/yaffs_checkptrw.c
+++ b/yaffs_checkptrw.c
@@ -135,7 +135,7 @@ int yaffs_CheckpointOpen(yaffs_Device *d
 		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 *d
 	
 	/* 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 *d
 	} 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(y
 	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(y
 		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 *
 		
 		
 		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 *d
 	
 	
 		if(dev->checkpointByteOffset < 0 ||
-		   dev->checkpointByteOffset >= dev->nBytesPerChunk) {
+		   dev->checkpointByteOffset >= dev->nDataBytesPerChunk) {
 		   
 		   	if(dev->checkpointCurrentBlock < 0){
 				yaffs_CheckpointFindNextCheckpointBlock(dev);
--- a/yaffs_fs.c
+++ b/yaffs_fs.c
@@ -1294,23 +1294,23 @@ static int yaffs_statfs(struct super_blo
 	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_interna
 	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_interna
 		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;
--- a/yaffs_guts.c
+++ b/yaffs_guts.c
@@ -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(y
 
 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_D
 	 */
 
 	dev->unmanagedTempAllocations++;
-	return YMALLOC(dev->nBytesPerChunk);
+	return YMALLOC(dev->nDataBytesPerChunk);
 
 }
 
@@ -297,14 +367,15 @@ static int yaffs_CheckChunkErased(struct
 	int retval = YAFFS_OK;
 	__u8 *data = yaffs_GetTempBuffer(dev, __LINE__);
 	yaffs_ExtendedTags tags;
-
-	yaffs_ReadChunkWithTagsFromNAND(dev, chunkInNAND, data, &tags);
+	int result;
+
+	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_WriteNewChunkWithTagsTo
 			 *
 			 * 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_WriteNewChunkWithTagsTo
 			 * needed.
 			 */
 			 
-#ifdef CONFIG_YAFFS_ALWAYS_CHECK_CHUNK_ERASED
-			bi->skipErasedCheck = 0;
-#endif
-			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));
+			 if(bi->gcPrioritise){
+			 		yaffs_DeleteChunk(dev, chunk, 1, __LINE__);
 			} else {
-				writeOk =
-				    yaffs_WriteChunkWithTagsToNAND(dev, chunk,
-								   data, tags);
-			}
+#ifdef CONFIG_YAFFS_ALWAYS_CHECK_CHUNK_ERASED
+
+				bi->skipErasedCheck = 0;
+
+#endif
+				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);
+				}
 			
-			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);
+				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);
 				
-			} 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(
 
 	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_FindBlockForGarbageColl
 	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_FindBlockForGarbageColl
 		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_FindBlockForGarbageColl
 		}
 	}
 
-	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_FindBlockForGarbageColl
 #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_O
 	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
 
 	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_Objec
 
 	int prevChunkId;
 	int retVal = 0;
+	int result = 0;
 
 	int newChunkId;
 	yaffs_ExtendedTags newTags;
@@ -2898,12 +2995,12 @@ int yaffs_UpdateObjectHeader(yaffs_Objec
 		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_ObjectHasCachedWriteDat
 	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
  * 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 
 	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 
 		 * 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 
 #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 
 	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 *
 	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 *
 
 			nBytesRead =
 			    in->variant.fileVariant.fileSize -
-			    ((chunk - 1) * dev->nBytesPerChunk);
-
-			if (nBytesRead > dev->nBytesPerChunk) {
-				nBytesRead = dev->nBytesPerChunk;
+			    ((chunk - 1) * dev->nDataBytesPerChunk);
+
+			if (nBytesRead > dev->nDataBytesPerChunk) {
+				nBytesRead = dev->nDataBytesPerChunk;
 			}
 
 			nToWriteBack =
@@ -3926,11 +4026,11 @@ int yaffs_WriteDataToFile(yaffs_Object *
 			     (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 *
 #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(yaf
 	yaffs_Device *dev = in->myDev;
 	int oldFileSize = in->variant.fileVariant.fileSize;
 
-	int lastDel = 1 + (oldFileSize - 1) / dev->nBytesPerChunk;
-
-	int startDel = 1 + (newSize + dev->nBytesPerChunk - 1) /
-	    dev->nBytesPerChunk;
+	int lastDel = 1 + (oldFileSize - 1) / dev->nDataBytesPerChunk;
+
+	int startDel = 1 + (newSize + dev->nDataBytesPerChunk - 1) /
+	    dev->nDataBytesPerChunk;
 	int i;
 	int chunkId;
 
@@ -4112,14 +4212,16 @@ static void yaffs_PruneResizedChunks(yaf
 
 }
 
-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, 
 
 		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_CheckObjectDetailsLoad
 	__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_Dev
 	int nBlocksToScan = 0;
 
 	int chunk;
+	int result;
 	int c;
 	int deleted;
 	yaffs_BlockState state;
@@ -5233,7 +5340,7 @@ static int yaffs_ScanBackwards(yaffs_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_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_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_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 * o
 	}
 #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_Obje
 		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 * 
 {
 	unsigned x;
 	int bits;
-	int extraBits;
 
 	T(YAFFS_TRACE_TRACING, (TSTR("yaffs: yaffs_GutsInitialise()" TENDSTR)));
 
@@ -6142,8 +6249,8 @@ int yaffs_GutsInitialise(yaffs_Device * 
 
 	/* 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 * 
 		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 * 
 
 
 
-	/* 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->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 * 
 		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->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;
 	}
--- a/yaffs_guts.h
+++ b/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 * o
 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);
--- a/yaffs_mtdif.c
+++ b/yaffs_mtdif.c
@@ -81,7 +81,7 @@ int nandmtd_WriteChunkToNAND(yaffs_Devic
 	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_Devic
 	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_Devi
 	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_Devi
 			/* 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_Devic
 {
 	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;
--- a/yaffs_mtdif2.c
+++ b/yaffs_mtdif2.c
@@ -41,7 +41,7 @@ int nandmtd2_WriteChunkWithTagsToNAND(ya
 #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(ya
 	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(y
 	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(y
 	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 yaf
 	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
 	retval =
 	    mtd->block_isbad(mtd,
 			     blockNo * dev->nChunksPerBlock *
-			     dev->nBytesPerChunk);
+			     dev->nDataBytesPerChunk);
 
 	if (retval) {
 		T(YAFFS_TRACE_MTD, (TSTR("block is bad" TENDSTR)));
--- a/yaffs_nand.c
+++ b/yaffs_nand.c
@@ -25,8 +25,13 @@ int yaffs_ReadChunkWithTagsFromNAND(yaff
 					   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(yaff
 	
 		yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, chunkInNAND/dev->nChunksPerBlock);
 		bi->gcPrioritise = 1;
+		dev->hasPendingPrioritisedGCs = 1;
 	}
 								
 	return result;