Add large NAND support and improve retirement handling
authorcharles <charles>
Tue, 3 Oct 2006 10:13:03 +0000 (10:13 +0000)
committercharles <charles>
Tue, 3 Oct 2006 10:13:03 +0000 (10:13 +0000)
15 files changed:
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

index 47a25a9..e25fea4 100644 (file)
 #
 # 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
 
index 714cd0f..2bd26e5 100644 (file)
@@ -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);
+
 
 
        
index 7e867f6..dcb3e5f 100644 (file)
@@ -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;
        }
index bf17f2c..aa8f661 100644 (file)
@@ -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)
index 849a56d..bf4f172 100644 (file)
@@ -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
index 67671ea..9d7804c 100644 (file)
@@ -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
index b670f11..0444d8f 100644 (file)
@@ -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);
 
index d059126..c651394 100644 (file)
@@ -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 $
  *
  */
  
 #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)
index 6ed976d..8d1bb66 100644 (file)
@@ -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);
index 30ac265..89fbcb7 100644 (file)
@@ -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;
index 130cf7a..306b9b4 100644 (file)
@@ -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;
        }
index e66efcf..cb9a8e0 100644 (file)
@@ -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);
index 1f40e8f..1e09650 100644 (file)
@@ -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;
index b7c973e..2c47951 100644 (file)
@@ -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)));
index 989e8d9..26acf20 100644 (file)
@@ -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;