X-Git-Url: http://www.aleph1.co.uk/gitweb/?p=yaffs%2F.git;a=blobdiff_plain;f=yaffs_guts.c;h=0ace425f92f3d055bf5ad7ced90354057f344676;hp=bf504e92a761862b5a4de00601bee2472d125d60;hb=8f88750ecfa15e4ddb80fcc6080a0c104fd27bd9;hpb=0b8a3dba1290b2e2e6d0c3be98f5162d1acb5af0 diff --git a/yaffs_guts.c b/yaffs_guts.c index bf504e9..0ace425 100644 --- a/yaffs_guts.c +++ b/yaffs_guts.c @@ -14,22 +14,25 @@ */ //yaffs_guts.c -const char *yaffs_guts_c_version="$Id: yaffs_guts.c,v 1.18 2003-01-21 20:42:27 charles Exp $"; +const char *yaffs_guts_c_version="$Id: yaffs_guts.c,v 1.39 2005-01-24 22:26:45 charles Exp $"; #include "yportenv.h" #include "yaffsinterface.h" #include "yaffs_guts.h" - - - #define YAFFS_PASSIVE_GC_CHUNKS 2 +#if 0 +// Use Steven Hill's ECC struff instead // External functions for ECC on data void nand_calculate_ecc (const u_char *dat, u_char *ecc_code); int nand_correct_data (u_char *dat, u_char *read_ecc, u_char *calc_ecc); - +#define yaffs_ECCCalculate(data,ecc) nand_calculate_ecc(data,ecc) +#define yaffs_ECCCorrect(data,read_ecc,calc_ecc) nand_correct_ecc(data,read_ecc,calc_ecc) +#else +#include "yaffs_ecc.h" +#endif // countBits is a quick way of counting the number of bits in a byte. // ie. countBits[n] holds the number of 1 bits in a byte with the value n. @@ -216,10 +219,6 @@ int yaffs_ReadChunkFromNAND(struct yaffs_DeviceStruct *dev, int retVal; yaffs_Spare localSpare; - __u8 calcEcc[3]; - int eccResult1,eccResult2; - struct yaffs_NANDSpare nspare; - dev->nPageReads++; @@ -240,10 +239,13 @@ int yaffs_ReadChunkFromNAND(struct yaffs_DeviceStruct *dev, { // Do ECC correction //Todo handle any errors - nand_calculate_ecc(data,calcEcc); - eccResult1 = nand_correct_data (data,spare->ecc1, calcEcc); - nand_calculate_ecc(&data[256],calcEcc); - eccResult2 = nand_correct_data (&data[256],spare->ecc2, calcEcc); + int eccResult1,eccResult2; + __u8 calcEcc[3]; + + yaffs_ECCCalculate(data,calcEcc); + eccResult1 = yaffs_ECCCorrect (data,spare->ecc1, calcEcc); + yaffs_ECCCalculate(&data[256],calcEcc); + eccResult2 = yaffs_ECCCorrect(&data[256],spare->ecc2, calcEcc); if(eccResult1>0) { @@ -276,6 +278,8 @@ int yaffs_ReadChunkFromNAND(struct yaffs_DeviceStruct *dev, } else { + // Must allocate enough memory for spare+2*sizeof(int) for ecc results from device. + struct yaffs_NANDSpare nspare; retVal = dev->readChunkFromNAND(dev,chunkInNAND,data,(yaffs_Spare*)&nspare); memcpy (spare, &nspare, sizeof(yaffs_Spare)); if(data && doErrorCorrection) @@ -298,7 +302,7 @@ int yaffs_ReadChunkFromNAND(struct yaffs_DeviceStruct *dev, T(YAFFS_TRACE_ERROR,(TSTR("**>>ecc error unfixed on chunk %d:1" TENDSTR),chunkInNAND)); } - if(nspare.eccres2 || nspare.eccres2) + if(nspare.eccres1 || nspare.eccres2) { // Hoosterman, we had a data problem on this page yaffs_HandleReadDataError(dev,chunkInNAND); @@ -316,12 +320,10 @@ static int yaffs_CheckChunkErased(struct yaffs_DeviceStruct *dev,int chunkInNAND static int init = 0; static __u8 cmpbuf[YAFFS_BYTES_PER_CHUNK]; static __u8 data[YAFFS_BYTES_PER_CHUNK]; - static __u8 spare[16]; - - - dev->readChunkFromNAND(dev,chunkInNAND,data,(yaffs_Spare *)spare); - - + // Might as well always allocate the larger size for dev->useNANDECC == true; + static __u8 spare[sizeof(struct yaffs_NANDSpare)]; + + dev->readChunkFromNAND(dev,chunkInNAND,data,(yaffs_Spare *)spare); if(!init) { @@ -583,8 +585,8 @@ void yaffs_SetObjectName(yaffs_Object *obj, const char *name) void yaffs_CalcECC(const __u8 *data, yaffs_Spare *spare) { - nand_calculate_ecc (data , spare->ecc1); - nand_calculate_ecc (&data[256] , spare->ecc2); + yaffs_ECCCalculate(data , spare->ecc1); + yaffs_ECCCalculate(&data[256] , spare->ecc2); } void yaffs_CalcTagsECC(yaffs_Tags *tags) @@ -780,11 +782,16 @@ static void yaffs_FreeTnode(yaffs_Device*dev, yaffs_Tnode *tn) static void yaffs_DeinitialiseTnodes(yaffs_Device*dev) { // Free the list of allocated tnodes - + yaffs_TnodeList *tmp; + while(dev->allocatedTnodeList) { + tmp = dev->allocatedTnodeList->next; + YFREE(dev->allocatedTnodeList->tnodes); - dev->allocatedTnodeList = dev->allocatedTnodeList->next; + YFREE(dev->allocatedTnodeList); + dev->allocatedTnodeList = tmp; + } dev->freeTnodes = NULL; @@ -1078,7 +1085,7 @@ static int yaffs_DeleteWorker(yaffs_Object *in, yaffs_Tnode *tn, __u32 level, in if(limit) { *limit = *limit-1; - if(limit <= 0) + if(*limit <= 0) { hitLimit = 1; } @@ -1149,8 +1156,12 @@ static int yaffs_SoftDeleteWorker(yaffs_Object *in, yaffs_Tnode *tn, __u32 level { if(tn->level0[i]) { - + // Note this does not find the real chunk, only the chunk group. + // We make an assumption that a chunk group is niot larger than a block. theChunk = (tn->level0[i] << in->myDev->chunkGroupBits); + T(YAFFS_TRACE_SCAN,(TSTR("soft delete tch %d cgb %d chunk %d" TENDSTR), + tn->level0[i],in->myDev->chunkGroupBits,theChunk)); + theBlock = yaffs_GetBlockInfo(in->myDev, theChunk/in->myDev->nChunksPerBlock); if(theBlock) { @@ -1433,6 +1444,16 @@ static void yaffs_FreeObject(yaffs_Object *tn) yaffs_Device *dev = tn->myDev; +#ifdef __KERNEL__ + if(tn->myInode) + { + // We're still hooked up to a cached inode. + // Don't delete now, but mark for later deletion + tn->deferedFree = 1; + return; + } +#endif + yaffs_UnhashObject(tn); // Link into the free list. @@ -1442,16 +1463,33 @@ static void yaffs_FreeObject(yaffs_Object *tn) } +#ifdef __KERNEL__ + +void yaffs_HandleDeferedFree(yaffs_Object *obj) +{ + if(obj->deferedFree) + { + yaffs_FreeObject(obj); + } +} + +#endif + static void yaffs_DeinitialiseObjects(yaffs_Device *dev) { // Free the list of allocated Objects + yaffs_ObjectList *tmp; + while( dev->allocatedObjectList) { + tmp = dev->allocatedObjectList->next; YFREE(dev->allocatedObjectList->objects); - dev->allocatedObjectList = dev->allocatedObjectList->next; + YFREE(dev->allocatedObjectList); + + dev->allocatedObjectList = tmp; } dev->freeObjects = NULL; @@ -1585,6 +1623,11 @@ yaffs_Object *yaffs_FindObjectByNumber(yaffs_Device *dev,__u32 number) in = list_entry(i, yaffs_Object,hashLink); if(in->objectId == number) { +#ifdef __KERNEL__ + // Don't tell the VFS about this if it has been marked for freeing + if(in->deferedFree) + return NULL; +#endif return in; } } @@ -1621,7 +1664,9 @@ yaffs_Object *yaffs_CreateNewObject(yaffs_Device *dev,int number,yaffs_ObjectTyp theObject->win_ctime[1] = theObject->win_mtime[1] = theObject->win_atime[1]; #else - theObject->st_atime = theObject->st_mtime = theObject->st_ctime = CURRENT_TIME; + + theObject->st_atime = theObject->st_mtime = theObject->st_ctime = Y_CURRENT_TIME; + #endif switch(type) { @@ -1722,10 +1767,11 @@ yaffs_Object *yaffs_MknodObject( yaffs_ObjectType type, #ifdef CONFIG_YAFFS_WINCE yfsd_WinFileTimeNow(in->win_atime); in->win_ctime[0] = in->win_mtime[0] = in->win_atime[0]; - in->win_ctime[1] = in->win_mtime[1] = in->win_atime[0]; + in->win_ctime[1] = in->win_mtime[1] = in->win_atime[1]; #else - in->st_atime = in->st_mtime = in->st_ctime = CURRENT_TIME; + + in->st_atime = in->st_mtime = in->st_ctime = Y_CURRENT_TIME; in->st_rdev = rdev; in->st_uid = uid; in->st_gid = gid; @@ -1851,7 +1897,7 @@ int yaffs_RenameObject(yaffs_Object *oldDir, const char *oldName, yaffs_Object * yaffs_Object *obj; int force = 0; -#ifdef YAFFS_CASE_INSENSITIVE +#ifdef CONFIG_YAFFS_CASE_INSENSITIVE // Special case for WinCE. // While look-up is case insensitive, the name isn't. // THerefore we might want to change x.txt to X.txt @@ -2140,7 +2186,7 @@ static int yaffs_AllocateChunk(yaffs_Device *dev,int useReserve) dev->allocationPage = 0; } - if(!useReserve && dev->nErasedBlocks <= YAFFS_RESERVED_BLOCKS) + if(!useReserve && dev->nErasedBlocks <= dev->nReservedBlocks) { // Not enough space to allocate unless we're allowed to use the reserve. return -1; @@ -2182,7 +2228,7 @@ static int yaffs_AllocateChunk(yaffs_Device *dev,int useReserve) static int yaffs_CheckSpaceForChunkCache(yaffs_Device *dev) { - return (dev->nErasedBlocks >= YAFFS_RESERVED_BLOCKS); + return (dev->nErasedBlocks >= dev->nReservedBlocks); } @@ -2277,6 +2323,7 @@ static int yaffs_GarbageCollectBlock(yaffs_Device *dev,int block) { // It's a header object->chunkId = newChunk; + object->serial = tags.serialNumber; } else { @@ -2363,7 +2410,7 @@ static int yaffs_CheckGarbageCollection(yaffs_Device *dev) //yaffs_DoUnlinkedFileDeletion(dev); - if(dev->nErasedBlocks <= (YAFFS_RESERVED_BLOCKS + YAFFS_GARBAGE_COLLECT_LOW_WATER)) + if(dev->nErasedBlocks <= (dev->nReservedBlocks + YAFFS_GARBAGE_COLLECT_LOW_WATER)) { aggressive = 1; } @@ -2403,7 +2450,7 @@ static int yaffs_CheckGarbageCollection(yaffs_Device *dev) //yaffs_DoUnlinkedFileDeletion(dev); - if(dev->nErasedBlocks <= (YAFFS_RESERVED_BLOCKS + 1)) + if(dev->nErasedBlocks <= (dev->nReservedBlocks + 1)) { aggressive = 1; } @@ -2818,6 +2865,7 @@ int yaffs_ReadChunkDataFromObject(yaffs_Object *in,int chunkInInode, __u8 *buffe } else { + memset(buffer,0,YAFFS_BYTES_PER_CHUNK); return 0; } @@ -2840,7 +2888,14 @@ static void yaffs_DeleteChunk(yaffs_Device *dev,int chunkId,int markNAND) if(markNAND) { yaffs_SpareInitialise(&spare); - + +#ifdef CONFIG_MTD_NAND_VERIFY_WRITE + + //read data before write, to ensure correct ecc + //if we're using MTD verification under Linux + yaffs_ReadChunkFromNAND(dev,chunkId,NULL,&spare,0); +#endif + spare.pageStatus = 0; // To mark it as deleted. @@ -3086,7 +3141,7 @@ static void yaffs_FlushFilesChunkCache(yaffs_Object *obj) int lowest; int i; yaffs_ChunkCache *cache; - int chunkWritten; + int chunkWritten = 0; int nBytes; int nCaches = obj->myDev->nShortOpCaches; @@ -3127,6 +3182,7 @@ static void yaffs_FlushFilesChunkCache(yaffs_Object *obj) cache->nBytes,1); cache->dirty = 0; + cache->object = NULL; } } while(cache && chunkWritten > 0); @@ -3159,10 +3215,14 @@ static yaffs_ChunkCache *yaffs_GrabChunkCacheWorker(yaffs_Device *dev) if(!dev->srCache[i].object) { //T(("Grabbing empty %d\n",i)); + + //printf("Grabbing empty %d\n",i); return &dev->srCache[i]; } } + + return NULL; theOne = -1; usage = 0; // just to stop the compiler grizzling @@ -3179,6 +3239,9 @@ static yaffs_ChunkCache *yaffs_GrabChunkCacheWorker(yaffs_Device *dev) } //T(("Grabbing non-empty %d\n",theOne)); + + //if(theOne >= 0) printf("Grabbed non-empty cache %d\n",theOne); + return theOne >= 0 ? &dev->srCache[theOne] : NULL; } else @@ -3195,6 +3258,7 @@ static yaffs_ChunkCache *yaffs_GrabChunkCache(yaffs_Device *dev) yaffs_Object *theObj; int usage; int i; + int pushout; if(dev->nShortOpCaches > 0) { @@ -3211,6 +3275,8 @@ static yaffs_ChunkCache *yaffs_GrabChunkCache(yaffs_Device *dev) theObj = dev->srCache[0].object; usage = dev->srCache[0].lastUse; + cache = &dev->srCache[0]; + pushout = 0; for(i = 1; i < dev->nShortOpCaches; i++) { @@ -3219,15 +3285,27 @@ static yaffs_ChunkCache *yaffs_GrabChunkCache(yaffs_Device *dev) { usage = dev->srCache[i].lastUse; theObj = dev->srCache[i].object; + cache = &dev->srCache[i]; + pushout = i; } } - yaffs_FlushFilesChunkCache(theObj); + if(!cache || cache->dirty) + { + + //printf("Dirty "); + yaffs_FlushFilesChunkCache(theObj); - // Try again - cache = yaffs_GrabChunkCacheWorker(dev); + // Try again + cache = yaffs_GrabChunkCacheWorker(dev); + } + else + { + //printf(" pushout %d\n",pushout); + } + } - + return cache; } else @@ -3345,6 +3423,7 @@ int yaffs_ReadDataFromFile(yaffs_Object *in, __u8 * buffer, __u32 offset, int nB int nToCopy; int n = nBytes; int nDone = 0; + yaffs_ChunkCache *cache; yaffs_Device *dev; @@ -3366,14 +3445,18 @@ int yaffs_ReadDataFromFile(yaffs_Object *in, __u8 * buffer, __u32 offset, int nB nToCopy = YAFFS_BYTES_PER_CHUNK - start; } - if(nToCopy != YAFFS_BYTES_PER_CHUNK) + cache = yaffs_FindChunkCache(in,chunk); + + // If the chunk is already in the cache or it is less than a whole chunk + // then use the cache (if there is caching) + // else bypass the cache. + if( cache || nToCopy != YAFFS_BYTES_PER_CHUNK) { - // An incomplete start or end chunk (or maybe both start and end chunk) if(dev->nShortOpCaches > 0) { - yaffs_ChunkCache *cache; + // If we can't find the data in the cache, then load it up. - cache = yaffs_FindChunkCache(in,chunk); + if(!cache) { cache = yaffs_GrabChunkCache(in->myDev); @@ -3591,7 +3674,7 @@ int yaffs_ResizeFile(yaffs_Object *in, int newSize) // using yaffs_DeleteChunk chunkId = yaffs_FindAndDeleteChunkInFile(in,i,NULL); - if(chunkId <= 0 || chunkId >= (dev->endBlock * 32)) + if(chunkId < (dev->startBlock * 32) || chunkId >= ((dev->endBlock+1) * 32)) { //T(("Found daft chunkId %d for %d\n",chunkId,i)); } @@ -3608,8 +3691,10 @@ int yaffs_ResizeFile(yaffs_Object *in, int newSize) int lastChunk = 1+ newSize/YAFFS_BYTES_PER_CHUNK; // Got to read and rewrite the last chunk with its new size. + // NB Got to zero pad to nuke old data yaffs_ReadChunkDataFromObject(in,lastChunk,dev->localBuffer); - + memset(dev->localBuffer + sizeOfPartialChunk,0, YAFFS_BYTES_PER_CHUNK - sizeOfPartialChunk); + yaffs_WriteChunkDataToObject(in,lastChunk,dev->localBuffer,sizeOfPartialChunk,1); } @@ -3661,7 +3746,7 @@ int yaffs_FlushFile(yaffs_Object *in, int updateTime) #ifdef CONFIG_YAFFS_WINCE yfsd_WinFileTimeNow(in->win_mtime); #else - in->st_mtime = CURRENT_TIME; + in->st_mtime = Y_CURRENT_TIME; #endif } @@ -3685,12 +3770,15 @@ static int yaffs_DoGenericObjectDeletion(yaffs_Object *in) yaffs_RemoveObjectFromDirectory(in); yaffs_DeleteChunk(in->myDev,in->chunkId,1); + in->chunkId = -1; +#if 0 #ifdef __KERNEL__ if(in->myInode) { in->myInode->u.generic_ip = NULL; - in->myInode = 0; + in->myInode = NULL; } +#endif #endif yaffs_FreeObject(in); return YAFFS_OK; @@ -3728,6 +3816,8 @@ static int yaffs_UnlinkFile(yaffs_Object *in) #ifdef __KERNEL__ if(!in->myInode) { + // Might be open at present, + // Caught by delete_inode in yaffs_fs.c immediateDeletion = 1; } @@ -4160,8 +4250,9 @@ static int yaffs_Scan(yaffs_Device *dev) { // Hoosterman, another problem.... // We're trying to use a non-directory as a directory - // Todo ... handle - T(YAFFS_TRACE_ERROR, (TSTR("yaffs tragedy: attempting to use non-directory as a directory in scan" TENDSTR))); + + T(YAFFS_TRACE_ERROR, (TSTR("yaffs tragedy: attempting to use non-directory as a directory in scan. Put in lost+found." TENDSTR))); + parent = dev->lostNFoundDir; } @@ -4514,9 +4605,10 @@ int yaffs_SetAttributes(yaffs_Object *obj, struct iattr *attr) if(valid & ATTR_UID) obj->st_uid = attr->ia_uid; if(valid & ATTR_GID) obj->st_gid = attr->ia_gid; - if(valid & ATTR_ATIME) obj->st_atime = attr->ia_atime; - if(valid & ATTR_CTIME) obj->st_ctime = attr->ia_ctime; - if(valid & ATTR_MTIME) obj->st_mtime = attr->ia_mtime; + if(valid & ATTR_ATIME) obj->st_atime = Y_TIME_CONVERT(attr->ia_atime); + if(valid & ATTR_CTIME) obj->st_ctime = Y_TIME_CONVERT(attr->ia_ctime); + if(valid & ATTR_MTIME) obj->st_mtime = Y_TIME_CONVERT(attr->ia_mtime); + if(valid & ATTR_SIZE) yaffs_ResizeFile(obj,attr->ia_size); @@ -4525,6 +4617,7 @@ int yaffs_SetAttributes(yaffs_Object *obj, struct iattr *attr) return YAFFS_OK; } + int yaffs_GetAttributes(yaffs_Object *obj, struct iattr *attr) { unsigned int valid = 0; @@ -4533,10 +4626,11 @@ int yaffs_GetAttributes(yaffs_Object *obj, struct iattr *attr) attr->ia_uid = obj->st_uid; valid |= ATTR_UID; attr->ia_gid = obj->st_gid; valid |= ATTR_GID; - attr->ia_atime = obj->st_atime; valid |= ATTR_ATIME; - attr->ia_ctime = obj->st_ctime; valid |= ATTR_CTIME; - attr->ia_mtime = obj->st_mtime; valid |= ATTR_MTIME; + Y_TIME_CONVERT(attr->ia_atime) = obj->st_atime; valid |= ATTR_ATIME; + Y_TIME_CONVERT(attr->ia_ctime) = obj->st_ctime; valid |= ATTR_CTIME; + Y_TIME_CONVERT(attr->ia_mtime) = obj->st_mtime; valid |= ATTR_MTIME; + attr->ia_size = yaffs_GetFileSize(obj); valid |= ATTR_SIZE; attr->ia_valid = valid; @@ -4600,6 +4694,19 @@ int yaffs_GutsInitialise(yaffs_Device *dev) int extraBits; int nBlocks; + if( dev->nBytesPerChunk != YAFFS_BYTES_PER_CHUNK || + dev->nChunksPerBlock < 2 || + dev->nReservedBlocks < 2 || + dev->startBlock <= 0 || + dev->endBlock <= 0 || + dev->endBlock <= (dev->startBlock + dev->nReservedBlocks) + ) + { + //these parameters must be set before stating yaffs + // Other parameters startBlock, + return YAFFS_FAIL; + } + if(!yaffs_CheckStructures()) @@ -4654,11 +4761,19 @@ int yaffs_GutsInitialise(yaffs_Device *dev) { dev->chunkGroupBits = bits - 16; } + dev->chunkGroupSize = 1 << dev->chunkGroupBits; + + if(dev->nChunksPerBlock < dev->chunkGroupSize) + { + // We have a problem because the soft delete won't work if + // the chunk group size > chunks per block. + // This can be remedied by using larger "virtual blocks". + + return YAFFS_FAIL; + } + - // Stuff to be taken out later - dev->nBytesPerChunk = YAFFS_BYTES_PER_CHUNK; - dev->nChunksPerBlock = YAFFS_CHUNKS_PER_BLOCK; // More device initialisation @@ -4743,7 +4858,10 @@ void yaffs_Deinitialise(yaffs_Device *dev) yaffs_DeinitialiseBlocks(dev); yaffs_DeinitialiseTnodes(dev); yaffs_DeinitialiseObjects(dev); + if(dev->nShortOpCaches > 0) + YFREE(dev->srCache); YFREE(dev->localBuffer); + dev->isMounted = 0; } } @@ -4770,7 +4888,7 @@ int yaffs_GetNumberOfFreeChunks(yaffs_Device *dev) } - printf("___________ nFreeChunks is %d nFree is %d\n",dev->nFreeChunks,nFree); + // printf("___________ nFreeChunks is %d nFree is %d\n",dev->nFreeChunks,nFree); if(nFree < 0) nFree = 0; @@ -4785,6 +4903,7 @@ int yaffs_GetNumberOfFreeChunks(yaffs_Device *dev) int nFree; int pending; int b; + int nDirtyCacheChunks=0; yaffs_BlockInfo *blk; @@ -4832,6 +4951,20 @@ int yaffs_GetNumberOfFreeChunks(yaffs_Device *dev) nFree += pending; + // Now count the number of dirty chunks in the cache and subtract those + + { + int i; + for(i = 0; i < dev->nShortOpCaches; i++) + { + if(dev->srCache[i].dirty) nDirtyCacheChunks++; + } + } + + nFree -= nDirtyCacheChunks; + + nFree -= ((dev->nReservedBlocks + 1) * dev->nChunksPerBlock); + if(nFree < 0) nFree = 0; return nFree; @@ -4881,3 +5014,6 @@ void yaffs_GutsTest(yaffs_Device *dev) + + +