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