X-Git-Url: http://www.aleph1.co.uk/gitweb/?p=yaffs2.git;a=blobdiff_plain;f=yaffs_guts.c;h=087ac958f61f127a9c9d8c99a89d1b5e71d70fb5;hp=d3539a019d52a8cea9f2fc073665a55cb395f6c7;hb=b3c7045d1ba097d7669f9b5cf4d2a6800e7ac30d;hpb=cbcdf80df41989092fce5f13bd5f89dc861497bb diff --git a/yaffs_guts.c b/yaffs_guts.c index d3539a0..087ac95 100644 --- a/yaffs_guts.c +++ b/yaffs_guts.c @@ -12,9 +12,10 @@ */ const char *yaffs_guts_c_version = - "$Id: yaffs_guts.c,v 1.102 2009-12-30 22:30:12 charles Exp $"; + "$Id: yaffs_guts.c,v 1.120 2010-03-15 23:10:34 charles Exp $"; #include "yportenv.h" +#include "yaffs_trace.h" #include "yaffsinterface.h" #include "yaffs_guts.h" @@ -33,7 +34,10 @@ const char *yaffs_guts_c_version = #include "yaffs_packedtags2.h" -#define YAFFS_PASSIVE_GC_CHUNKS 2 +/* Note YAFFS_GC_GOOD_ENOUGH must be <= YAFFS_GC_PASSIVE_THRESHOLD */ +#define YAFFS_GC_GOOD_ENOUGH 2 +#define YAFFS_GC_PASSIVE_THRESHOLD 4 +#define YAFFS_SMALL_HOLE_THRESHOLD 3 #include "yaffs_ecc.h" @@ -113,6 +117,7 @@ static yaffs_Tnode *yaffs_FindLevel0Tnode(yaffs_Device *dev, yaffs_FileStructure *fStruct, __u32 chunkId); +static int yaffs_HandleHole(yaffs_Object *obj, loff_t newSize); static void yaffs_SkipRestOfBlock(yaffs_Device *dev); static int yaffs_VerifyChunkWritten(yaffs_Device *dev, int chunkInNAND, @@ -209,7 +214,7 @@ static int yaffs_InitialiseTempBuffers(yaffs_Device *dev) for (i = 0; buf && i < YAFFS_N_TEMP_BUFFERS; i++) { dev->tempBuffer[i].line = 0; /* not in use */ dev->tempBuffer[i].buffer = buf = - YMALLOC_DMA(dev->totalBytesPerChunk); + YMALLOC_DMA(dev->param.totalBytesPerChunk); } return buf ? YAFFS_OK : YAFFS_FAIL; @@ -292,7 +297,7 @@ int yaffs_IsManagedTempBuffer(yaffs_Device *dev, const __u8 *buffer) return 1; } - for (i = 0; i < dev->nShortOpCaches; i++) { + for (i = 0; i < dev->param.nShortOpCaches; i++) { if (dev->srCache[i].data == buffer) return 1; } @@ -326,7 +331,7 @@ static Y_INLINE __u8 *yaffs_BlockBits(yaffs_Device *dev, int blk) static Y_INLINE void yaffs_VerifyChunkBitId(yaffs_Device *dev, int blk, int chunk) { if (blk < dev->internalStartBlock || blk > dev->internalEndBlock || - chunk < 0 || chunk >= dev->nChunksPerBlock) { + chunk < 0 || chunk >= dev->param.nChunksPerBlock) { T(YAFFS_TRACE_ERROR, (TSTR("**>> yaffs: Chunk Id (%d:%d) invalid"TENDSTR), blk, chunk)); @@ -403,16 +408,19 @@ static int yaffs_CountChunkBits(yaffs_Device *dev, int blk) static int yaffs_SkipVerification(yaffs_Device *dev) { + dev=dev; return !(yaffs_traceMask & (YAFFS_TRACE_VERIFY | YAFFS_TRACE_VERIFY_FULL)); } static int yaffs_SkipFullVerification(yaffs_Device *dev) { + dev=dev; return !(yaffs_traceMask & (YAFFS_TRACE_VERIFY_FULL)); } static int yaffs_SkipNANDVerification(yaffs_Device *dev) { + dev=dev; return !(yaffs_traceMask & (YAFFS_TRACE_VERIFY_NAND)); } @@ -453,9 +461,9 @@ static void yaffs_VerifyBlock(yaffs_Device *dev, yaffs_BlockInfo *bi, int n) actuallyUsed = bi->pagesInUse - bi->softDeletions; - if (bi->pagesInUse < 0 || bi->pagesInUse > dev->nChunksPerBlock || - bi->softDeletions < 0 || bi->softDeletions > dev->nChunksPerBlock || - actuallyUsed < 0 || actuallyUsed > dev->nChunksPerBlock) + if (bi->pagesInUse < 0 || bi->pagesInUse > dev->param.nChunksPerBlock || + bi->softDeletions < 0 || bi->softDeletions > dev->param.nChunksPerBlock || + actuallyUsed < 0 || actuallyUsed > dev->param.nChunksPerBlock) T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has illegal values pagesInUsed %d softDeletions %d"TENDSTR), n, bi->pagesInUse, bi->softDeletions)); @@ -469,7 +477,7 @@ static void yaffs_VerifyBlock(yaffs_Device *dev, yaffs_BlockInfo *bi, int n) /* Check that the sequence number is valid. * Ten million is legal, but is very unlikely */ - if (dev->isYaffs2 && + if (dev->param.isYaffs2 && (bi->blockState == YAFFS_BLOCK_STATE_ALLOCATING || bi->blockState == YAFFS_BLOCK_STATE_FULL) && (bi->sequenceNumber < YAFFS_LOWEST_SEQUENCE_NUMBER || bi->sequenceNumber > 10000000)) T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has suspect sequence number of %d"TENDSTR), @@ -681,12 +689,6 @@ static void yaffs_VerifyFile(yaffs_Object *obj) actualTallness = obj->variant.fileVariant.topLevel; - if (requiredTallness > actualTallness) - T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d had tnode tallness %d, needs to be %d"TENDSTR), - obj->objectId, actualTallness, requiredTallness)); - - /* Check that the chunks in the tnode tree are all correct. * We do this by scanning through the tnode tree and * checking the tags for every chunk match. @@ -761,15 +763,15 @@ static void yaffs_VerifyObject(yaffs_Object *obj) /* Check sane object header chunk */ - chunkMin = dev->internalStartBlock * dev->nChunksPerBlock; - chunkMax = (dev->internalEndBlock+1) * dev->nChunksPerBlock - 1; + chunkMin = dev->internalStartBlock * dev->param.nChunksPerBlock; + chunkMax = (dev->internalEndBlock+1) * dev->param.nChunksPerBlock - 1; chunkInRange = (((unsigned)(obj->hdrChunk)) >= chunkMin && ((unsigned)(obj->hdrChunk)) <= chunkMax); chunkIdOk = chunkInRange || (obj->hdrChunk == 0); chunkValid = chunkInRange && yaffs_CheckChunkBit(dev, - obj->hdrChunk / dev->nChunksPerBlock, - obj->hdrChunk % dev->nChunksPerBlock); + obj->hdrChunk / dev->param.nChunksPerBlock, + obj->hdrChunk % dev->param.nChunksPerBlock); chunkShouldNotBeDeleted = chunkInRange && !chunkValid; if (!obj->fake && @@ -1049,6 +1051,85 @@ static int yaffs_WriteNewChunkWithTagsToNAND(struct yaffs_DeviceStruct *dev, return chunk; } + +/* + * Oldest Dirty Sequence Number handling. + */ + +/* yaffs_CalcOldestDirtySequence() + * yaffs_FindOldestDirtySequence() + * Calculate the oldest dirty sequence number if we don't know it. + */ +static void yaffs_CalcOldestDirtySequence(yaffs_Device *dev) +{ + int i; + unsigned seq; + unsigned blockNo = 0; + yaffs_BlockInfo *b; + + if(!dev->param.isYaffs2) + return; + + /* Find the oldest dirty sequence number. */ + seq = dev->sequenceNumber + 1; + b = dev->blockInfo; + for (i = dev->internalStartBlock; i <= dev->internalEndBlock; i++) { + if (b->blockState == YAFFS_BLOCK_STATE_FULL && + (b->pagesInUse - b->softDeletions) < dev->param.nChunksPerBlock && + b->sequenceNumber < seq) { + seq = b->sequenceNumber; + blockNo = i; + } + b++; + } + + if(blockNo){ + dev->oldestDirtySequence = seq; + dev->oldestDirtyBlock = blockNo; + } + +} + + +static void yaffs_FindOldestDirtySequence(yaffs_Device *dev) +{ + if(dev->param.isYaffs2 && !dev->oldestDirtySequence) + yaffs_CalcOldestDirtySequence(dev); +} + +/* + * yaffs_ClearOldestDirtySequence() + * Called when a block is erased or marked bad. (ie. when its sequenceNumber + * becomes invalid). If the value matches the oldest then we clear + * dev->oldestDirtySequence to force its recomputation. + */ +static void yaffs_ClearOldestDirtySequence(yaffs_Device *dev, yaffs_BlockInfo *bi) +{ + + if(!dev->param.isYaffs2) + return; + + if(!bi || bi->sequenceNumber == dev->oldestDirtySequence){ + dev->oldestDirtySequence = 0; + dev->oldestDirtyBlock = 0; + } +} + +/* + * yaffs_UpdateOldestDirtySequence() + * Update the oldest dirty sequence number whenever we dirty a block. + * Only do this if the oldestDirtySequence is actually being tracked. + */ +static void yaffs_UpdateOldestDirtySequence(yaffs_Device *dev, unsigned blockNo, yaffs_BlockInfo *bi) +{ + if(dev->param.isYaffs2 && dev->oldestDirtySequence){ + if(dev->oldestDirtySequence > bi->sequenceNumber){ + dev->oldestDirtySequence = bi->sequenceNumber; + dev->oldestDirtyBlock = blockNo; + } + } +} + /* * Block retiring for handling a broken block. */ @@ -1058,6 +1139,8 @@ static void yaffs_RetireBlock(yaffs_Device *dev, int blockInNAND) yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, blockInNAND); yaffs_InvalidateCheckpoint(dev); + + yaffs_ClearOldestDirtySequence(dev,bi); if (yaffs_MarkBlockBad(dev, blockInNAND) != YAFFS_OK) { if (yaffs_EraseBlockInNAND(dev, blockInNAND) != YAFFS_OK) { @@ -1066,14 +1149,14 @@ static void yaffs_RetireBlock(yaffs_Device *dev, int blockInNAND) TENDSTR), blockInNAND)); } else { yaffs_ExtendedTags tags; - int chunkId = blockInNAND * dev->nChunksPerBlock; + int chunkId = blockInNAND * dev->param.nChunksPerBlock; __u8 *buffer = yaffs_GetTempBuffer(dev, __LINE__); memset(buffer, 0xff, dev->nDataBytesPerChunk); yaffs_InitialiseTags(&tags); tags.sequenceNumber = YAFFS_SEQUENCE_BAD_BLOCK; - if (dev->writeChunkWithTagsToNAND(dev, chunkId - + if (dev->param.writeChunkWithTagsToNAND(dev, chunkId - dev->chunkOffset, buffer, &tags) != YAFFS_OK) T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: Failed to " TCONT("write bad block marker to block %d") @@ -1099,11 +1182,18 @@ static void yaffs_HandleWriteChunkOk(yaffs_Device *dev, int chunkInNAND, const __u8 *data, const yaffs_ExtendedTags *tags) { + dev=dev; + chunkInNAND=chunkInNAND; + data=data; + tags=tags; } static void yaffs_HandleUpdateChunk(yaffs_Device *dev, int chunkInNAND, const yaffs_ExtendedTags *tags) { + dev=dev; + chunkInNAND=chunkInNAND; + tags=tags; } void yaffs_HandleChunkError(yaffs_Device *dev, yaffs_BlockInfo *bi) @@ -1124,7 +1214,7 @@ void yaffs_HandleChunkError(yaffs_Device *dev, yaffs_BlockInfo *bi) static void yaffs_HandleWriteChunkError(yaffs_Device *dev, int chunkInNAND, int erasedOk) { - int blockInNAND = chunkInNAND / dev->nChunksPerBlock; + int blockInNAND = chunkInNAND / dev->param.nChunksPerBlock; yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, blockInNAND); yaffs_HandleChunkError(dev, bi); @@ -1188,11 +1278,22 @@ static void yaffs_SetObjectName(yaffs_Object *obj, const YCHAR *name) * adds them to the tnode free list. * Don't use this function directly */ +static Y_INLINE int yaffs_CalcTnodeSize(yaffs_Device *dev) +{ + int tnodeSize; + /* Calculate the tnode size in bytes for variable width tnode support. + * Must be a multiple of 32-bits */ + tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8; + + if (tnodeSize < sizeof(yaffs_Tnode)) + tnodeSize = sizeof(yaffs_Tnode); + return tnodeSize; +} static int yaffs_CreateTnodes(yaffs_Device *dev, int nTnodes) { int i; - int tnodeSize; + int tnodeSize = yaffs_CalcTnodeSize(dev); yaffs_Tnode *newTnodes; __u8 *mem; yaffs_Tnode *curr; @@ -1202,12 +1303,6 @@ static int yaffs_CreateTnodes(yaffs_Device *dev, int nTnodes) if (nTnodes < 1) return YAFFS_OK; - /* Calculate the tnode size in bytes for variable width tnode support. - * Must be a multiple of 32-bits */ - tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8; - - if (tnodeSize < sizeof(yaffs_Tnode)) - tnodeSize = sizeof(yaffs_Tnode); /* make these things */ @@ -1280,6 +1375,11 @@ static yaffs_Tnode *yaffs_GetTnodeRaw(yaffs_Device *dev) { yaffs_Tnode *tn = NULL; +#ifdef CONFIG_YAFFS_VALGRIND_TEST + tn = YMALLOC(yaffs_CalcTnodeSize(dev)); + if(tn) + dev->nTnodesCreated++; +#else /* If there are none left make more */ if (!dev->freeTnodes) yaffs_CreateTnodes(dev, YAFFS_ALLOCATION_NTNODES); @@ -1296,7 +1396,7 @@ static yaffs_Tnode *yaffs_GetTnodeRaw(yaffs_Device *dev) dev->freeTnodes = dev->freeTnodes->internal[0]; dev->nFreeTnodes--; } - +#endif dev->nCheckpointBlocksRequired = 0; /* force recalculation*/ return tn; @@ -1305,10 +1405,7 @@ static yaffs_Tnode *yaffs_GetTnodeRaw(yaffs_Device *dev) static yaffs_Tnode *yaffs_GetTnode(yaffs_Device *dev) { yaffs_Tnode *tn = yaffs_GetTnodeRaw(dev); - int tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8; - - if (tnodeSize < sizeof(yaffs_Tnode)) - tnodeSize = sizeof(yaffs_Tnode); + int tnodeSize = yaffs_CalcTnodeSize(dev); if (tn) memset(tn, 0, tnodeSize); @@ -1320,6 +1417,10 @@ static yaffs_Tnode *yaffs_GetTnode(yaffs_Device *dev) static void yaffs_FreeTnode(yaffs_Device *dev, yaffs_Tnode *tn) { if (tn) { +#ifdef CONFIG_YAFFS_VALGRIND_TEST + YFREE(tn); + dev->nTnodesCreated--; +#else #ifdef CONFIG_YAFFS_TNODE_LIST_DEBUG if (tn->internal[YAFFS_NTNODES_INTERNAL] != 0) { /* Hoosterman, this thing looks like it is already in the list */ @@ -1331,6 +1432,7 @@ static void yaffs_FreeTnode(yaffs_Device *dev, yaffs_Tnode *tn) tn->internal[0] = dev->freeTnodes; dev->freeTnodes = tn; dev->nFreeTnodes++; +#endif } dev->nCheckpointBlocksRequired = 0; /* force recalculation*/ } @@ -1351,6 +1453,7 @@ static void yaffs_DeinitialiseTnodes(yaffs_Device *dev) dev->freeTnodes = NULL; dev->nFreeTnodes = 0; + dev->nTnodesCreated = 0; } static void yaffs_InitialiseTnodes(yaffs_Device *dev) @@ -1438,6 +1541,8 @@ static yaffs_Tnode *yaffs_FindLevel0Tnode(yaffs_Device *dev, int requiredTallness; int level = fStruct->topLevel; + dev=dev; + /* Check sane level and chunk Id */ if (level < 0 || level > YAFFS_TNODES_MAX_LEVEL) return NULL; @@ -1547,7 +1652,6 @@ static yaffs_Tnode *yaffs_AddOrFindLevel0Tnode(yaffs_Device *dev, tn->internal[x] = yaffs_GetTnode(dev); if(!tn->internal[x]) return NULL; - } else if (l == 1) { /* Looking from level 1 at level 0 */ if (passedTn) { @@ -1585,8 +1689,8 @@ static int yaffs_FindChunkInGroup(yaffs_Device *dev, int theChunk, int j; for (j = 0; theChunk && j < dev->chunkGroupSize; j++) { - if (yaffs_CheckChunkBit(dev, theChunk / dev->nChunksPerBlock, - theChunk % dev->nChunksPerBlock)) { + if (yaffs_CheckChunkBit(dev, theChunk / dev->param.nChunksPerBlock, + theChunk % dev->param.nChunksPerBlock)) { if(dev->chunkGroupSize == 1) return theChunk; @@ -1701,13 +1805,16 @@ static int yaffs_DeleteWorker(yaffs_Object *in, yaffs_Tnode *tn, __u32 level, static void yaffs_SoftDeleteChunk(yaffs_Device *dev, int chunk) { yaffs_BlockInfo *theBlock; + unsigned blockNo; T(YAFFS_TRACE_DELETION, (TSTR("soft delete chunk %d" TENDSTR), chunk)); - theBlock = yaffs_GetBlockInfo(dev, chunk / dev->nChunksPerBlock); + blockNo = chunk / dev->param.nChunksPerBlock; + theBlock = yaffs_GetBlockInfo(dev, blockNo); if (theBlock) { theBlock->softDeletions++; dev->nFreeChunks++; + yaffs_UpdateOldestDirtySequence(dev, blockNo, theBlock); } } @@ -1835,15 +1942,10 @@ static yaffs_Tnode *yaffs_PruneWorker(yaffs_Device *dev, yaffs_Tnode *tn, hasData++; } } else { - int tnodeSize; + int tnodeSize_u32 = yaffs_CalcTnodeSize(dev)/sizeof(__u32); __u32 *map = (__u32 *)tn; - tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8; - - if (tnodeSize < sizeof(yaffs_Tnode)) - tnodeSize = sizeof(yaffs_Tnode); - tnodeSize /= sizeof(__u32); - for(i = 0; !hasData && i < tnodeSize; i++){ + for(i = 0; !hasData && i < tnodeSize_u32; i++){ if(map[i]) hasData++; } @@ -1961,8 +2063,10 @@ static yaffs_Object *yaffs_AllocateEmptyObject(yaffs_Device *dev) { yaffs_Object *tn = NULL; -#ifdef VALGRIND_TEST +#ifdef CONFIG_YAFFS_VALGRIND_TEST tn = YMALLOC(sizeof(yaffs_Object)); + if(tn) + dev->nObjectsCreated++; #else /* If there are none left make more */ if (!dev->freeObjects) @@ -2049,17 +2153,16 @@ static void yaffs_FreeObject(yaffs_Object *tn) { yaffs_Device *dev = tn->myDev; -#ifdef __KERNEL__ T(YAFFS_TRACE_OS, (TSTR("FreeObject %p inode %p"TENDSTR), tn, tn->myInode)); -#endif + if (!tn) + YBUG(); if (tn->parent) YBUG(); if (!ylist_empty(&tn->siblings)) YBUG(); -#ifdef __KERNEL__ if (tn->myInode) { /* We're still hooked up to a cached inode. * Don't delete now, but mark for later deletion @@ -2067,12 +2170,12 @@ static void yaffs_FreeObject(yaffs_Object *tn) tn->deferedFree = 1; return; } -#endif yaffs_UnhashObject(tn); -#ifdef VALGRIND_TEST +#ifdef CONFIG_YAFFS_VALGRIND_TEST YFREE(tn); + dev->nObjectsCreated--; tn = NULL; #else /* Link into the free list. */ @@ -2083,7 +2186,6 @@ static void yaffs_FreeObject(yaffs_Object *tn) dev->nCheckpointBlocksRequired = 0; /* force recalculation*/ } -#ifdef __KERNEL__ void yaffs_HandleDeferedFree(yaffs_Object *obj) { @@ -2091,7 +2193,6 @@ void yaffs_HandleDeferedFree(yaffs_Object *obj) yaffs_FreeObject(obj); } -#endif static void yaffs_DeinitialiseObjects(yaffs_Device *dev) { @@ -2109,6 +2210,7 @@ static void yaffs_DeinitialiseObjects(yaffs_Device *dev) dev->freeObjects = NULL; dev->nFreeObjects = 0; + dev->nObjectsCreated = 0; } static void yaffs_InitialiseObjects(yaffs_Device *dev) @@ -2127,33 +2229,21 @@ static void yaffs_InitialiseObjects(yaffs_Device *dev) static int yaffs_FindNiceObjectBucket(yaffs_Device *dev) { - static int x; int i; int l = 999; int lowest = 999999; - /* First let's see if we can find one that's empty. */ - - for (i = 0; i < 10 && lowest > 0; i++) { - x++; - x %= YAFFS_NOBJECT_BUCKETS; - if (dev->objectBucket[x].count < lowest) { - lowest = dev->objectBucket[x].count; - l = x; - } - - } - /* If we didn't find an empty list, then try - * looking a bit further for a short one + /* Search for the shortest list or one that + * isn't too long. */ - for (i = 0; i < 10 && lowest > 3; i++) { - x++; - x %= YAFFS_NOBJECT_BUCKETS; - if (dev->objectBucket[x].count < lowest) { - lowest = dev->objectBucket[x].count; - l = x; + for (i = 0; i < 10 && lowest > 4; i++) { + dev->bucketFinder++; + dev->bucketFinder %= YAFFS_NOBJECT_BUCKETS; + if (dev->objectBucket[dev->bucketFinder].count < lowest) { + lowest = dev->objectBucket[dev->bucketFinder].count; + l = dev->bucketFinder; } } @@ -2213,11 +2303,10 @@ yaffs_Object *yaffs_FindObjectByNumber(yaffs_Device *dev, __u32 number) if (i) { in = ylist_entry(i, yaffs_Object, hashLink); if (in->objectId == number) { -#ifdef __KERNEL__ + /* Don't tell the VFS about this one if it is defered free */ if (in->deferedFree) return NULL; -#endif return in; } @@ -2230,7 +2319,7 @@ yaffs_Object *yaffs_FindObjectByNumber(yaffs_Device *dev, __u32 number) yaffs_Object *yaffs_CreateNewObject(yaffs_Device *dev, int number, yaffs_ObjectType type) { - yaffs_Object *theObject; + yaffs_Object *theObject=NULL; yaffs_Tnode *tn = NULL; if (number < 0) @@ -2280,6 +2369,8 @@ yaffs_Object *yaffs_CreateNewObject(yaffs_Device *dev, int number, case YAFFS_OBJECT_TYPE_DIRECTORY: YINIT_LIST_HEAD(&theObject->variant.directoryVariant. children); + YINIT_LIST_HEAD(&theObject->variant.directoryVariant. + dirty); break; case YAFFS_OBJECT_TYPE_SYMLINK: case YAFFS_OBJECT_TYPE_HARDLINK: @@ -2372,6 +2463,7 @@ static yaffs_Object *yaffs_MknodObject(yaffs_ObjectType type, + if (in) { in->hdrChunk = 0; in->valid = 1; @@ -2497,7 +2589,7 @@ static int yaffs_ChangeObjectName(yaffs_Object *obj, yaffs_Object *newDir, } /* TODO: Do we need this different handling for YAFFS2 and YAFFS1?? */ - if (obj->myDev->isYaffs2) + if (obj->myDev->param.isYaffs2) unlinkOp = (newDir == obj->myDev->unlinkedDir); else unlinkOp = (newDir == obj->myDev->unlinkedDir @@ -2583,12 +2675,12 @@ int yaffs_RenameObject(yaffs_Object *oldDir, const YCHAR *oldName, * Note we must disable gc otherwise it can mess up the shadowing. * */ - dev->isDoingGC=1; + dev->gcDisable=1; yaffs_ChangeObjectName(obj, newDir, newName, force, existingTarget->objectId); existingTarget->isShadowed = 1; yaffs_UnlinkObject(existingTarget); - dev->isDoingGC=0; + dev->gcDisable=0; } result = yaffs_ChangeObjectName(obj, newDir, newName, 1, 0); @@ -2623,7 +2715,7 @@ static int yaffs_InitialiseBlocks(yaffs_Device *dev) if (dev->blockInfo) { /* Set up dynamic blockinfo stuff. */ - dev->chunkBitmapStride = (dev->nChunksPerBlock + 7) / 8; /* round up bytes */ + dev->chunkBitmapStride = (dev->param.nChunksPerBlock + 7) / 8; /* round up bytes */ dev->chunkBits = YMALLOC(dev->chunkBitmapStride * nBlocks); if (!dev->chunkBits) { dev->chunkBits = YMALLOC_ALT(dev->chunkBitmapStride * nBlocks); @@ -2663,33 +2755,14 @@ static void yaffs_DeinitialiseBlocks(yaffs_Device *dev) static int yaffs_BlockNotDisqualifiedFromGC(yaffs_Device *dev, yaffs_BlockInfo *bi) { - int i; - __u32 seq; - yaffs_BlockInfo *b; - if (!dev->isYaffs2) + if (!dev->param.isYaffs2) return 1; /* disqualification only applies to yaffs2. */ if (!bi->hasShrinkHeader) return 1; /* can gc */ - /* Find the oldest dirty sequence number if we don't know it and save it - * so we don't have to keep recomputing it. - */ - if (!dev->oldestDirtySequence) { - seq = dev->sequenceNumber; - - for (i = dev->internalStartBlock; i <= dev->internalEndBlock; - i++) { - b = yaffs_GetBlockInfo(dev, i); - if (b->blockState == YAFFS_BLOCK_STATE_FULL && - (b->pagesInUse - b->softDeletions) < - dev->nChunksPerBlock && b->sequenceNumber < seq) { - seq = b->sequenceNumber; - } - } - dev->oldestDirtySequence = seq; - } + yaffs_FindOldestDirtySequence(dev); /* Can't do gc of this block if there are any blocks older than this one that have * discarded pages. @@ -2697,109 +2770,67 @@ static int yaffs_BlockNotDisqualifiedFromGC(yaffs_Device *dev, return (bi->sequenceNumber <= dev->oldestDirtySequence); } -/* FindDiretiestBlock is used to select the dirtiest block (or close enough) - * for garbage collection. +/* + * yaffs_FindRefreshBlock() + * periodically finds the oldest full block by sequence number for refreshing. + * Only for yaffs2. */ - -static int yaffs_FindBlockForGarbageCollection(yaffs_Device *dev, - int aggressive) +static __u32 yaffs_FindRefreshBlock(yaffs_Device *dev) { - int b = dev->currentDirtyChecker; - - int i; - int iterations; - int dirtiest = -1; - int pagesInUse = 0; - int prioritised = 0; - yaffs_BlockInfo *bi; - int pendingPrioritisedExist = 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++) { + __u32 b ; - bi = yaffs_GetBlockInfo(dev, i); - /* yaffs_VerifyBlock(dev,bi,i); */ - - if (bi->gcPrioritise) { - pendingPrioritisedExist = 1; - if (bi->blockState == YAFFS_BLOCK_STATE_FULL && - yaffs_BlockNotDisqualifiedFromGC(dev, bi)) { - pagesInUse = (bi->pagesInUse - bi->softDeletions); - dirtiest = i; - prioritised = 1; - aggressive = 1; /* Fool the non-aggressive skip logiv below */ - } - } - } + __u32 oldest = 0; + __u32 oldestSequence = 0; - if (!pendingPrioritisedExist) /* None found, so we can clear this */ - dev->hasPendingPrioritisedGCs = 0; - } + yaffs_BlockInfo *bi; - /* If we're doing aggressive GC then we are happy to take a less-dirty block, and - * search harder. - * else (we're doing a leasurely gc), then we only bother to do this if the - * block has only a few pages in use. + /* + * If refresh period < 10 then refreshing is disabled. */ + if(dev->param.refreshPeriod < 10 || + !dev->param.isYaffs2) + return oldest; - dev->nonAggressiveSkip--; - - if (!aggressive && (dev->nonAggressiveSkip > 0)) - return -1; - - if (!prioritised) - pagesInUse = - (aggressive) ? dev->nChunksPerBlock : YAFFS_PASSIVE_GC_CHUNKS + 1; - - if (aggressive) - iterations = - dev->internalEndBlock - dev->internalStartBlock + 1; - else { - iterations = - dev->internalEndBlock - dev->internalStartBlock + 1; - iterations = iterations / 16; - if (iterations > 200) - iterations = 200; - } + /* + * Fix broken values. + */ + if(dev->refreshSkip > dev->param.refreshPeriod) + dev->refreshSkip = dev->param.refreshPeriod; - for (i = 0; i <= iterations && pagesInUse > 0 && !prioritised; i++) { - b++; - if (b < dev->internalStartBlock || b > dev->internalEndBlock) - b = dev->internalStartBlock; + if(dev->refreshSkip > 0) + return oldest; - if (b < dev->internalStartBlock || b > dev->internalEndBlock) { - T(YAFFS_TRACE_ERROR, - (TSTR("**>> Block %d is not valid" TENDSTR), b)); - YBUG(); - } + /* + * Refresh skip is now zero. + * We'll do a refresh this time around.... + * Update the refresh skip and find the oldest block. + */ + dev->refreshSkip = dev->param.refreshPeriod; + dev->refreshCount++; + bi = dev->blockInfo; + for (b = dev->internalStartBlock; b <=dev->internalEndBlock; b++){ - bi = yaffs_GetBlockInfo(dev, b); + if (bi->blockState == YAFFS_BLOCK_STATE_FULL){ - if (bi->blockState == YAFFS_BLOCK_STATE_FULL && - (bi->pagesInUse - bi->softDeletions) < pagesInUse && - yaffs_BlockNotDisqualifiedFromGC(dev, bi)) { - dirtiest = b; - pagesInUse = (bi->pagesInUse - bi->softDeletions); + if(oldest < 1 || + bi->sequenceNumber < oldestSequence){ + oldest = b; + oldestSequence = bi->sequenceNumber; + } } + bi++; } - dev->currentDirtyChecker = b; - - if (dirtiest > 0) { + if (oldest > 0) { T(YAFFS_TRACE_GC, - (TSTR("GC Selected block %d with %d free, prioritised:%d" TENDSTR), dirtiest, - dev->nChunksPerBlock - pagesInUse, prioritised)); + (TSTR("GC refresh count %d selected block %d with sequenceNumber %d" TENDSTR), + dev->refreshCount, oldest, oldestSequence)); } - dev->oldestDirtySequence = 0; - - if (dirtiest > 0) - dev->nonAggressiveSkip = 4; - - return dirtiest; + return oldest; } + static void yaffs_BlockBecameDirty(yaffs_Device *dev, int blockNo) { yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, blockNo); @@ -2814,8 +2845,20 @@ static void yaffs_BlockBecameDirty(yaffs_Device *dev, int blockNo) (TSTR("yaffs_BlockBecameDirty block %d state %d %s"TENDSTR), blockNo, bi->blockState, (bi->needsRetiring) ? "needs retiring" : "")); + yaffs_ClearOldestDirtySequence(dev,bi); + bi->blockState = YAFFS_BLOCK_STATE_DIRTY; + /* If this is the block being garbage collected then stop gc'ing this block */ + if(blockNo == dev->gcBlock) + dev->gcBlock = 0; + + /* If this block is currently the best candidate for gc then drop as a candidate */ + if(blockNo == dev->gcDirtiest){ + dev->gcDirtiest = 0; + dev->gcPagesInUse = 0; + } + if (!bi->needsRetiring) { yaffs_InvalidateCheckpoint(dev); erasedOk = yaffs_EraseBlockInNAND(dev, blockNo); @@ -2829,9 +2872,9 @@ static void yaffs_BlockBecameDirty(yaffs_Device *dev, int blockNo) if (erasedOk && ((yaffs_traceMask & YAFFS_TRACE_ERASE) || !yaffs_SkipVerification(dev))) { int i; - for (i = 0; i < dev->nChunksPerBlock; i++) { + for (i = 0; i < dev->param.nChunksPerBlock; i++) { if (!yaffs_CheckChunkErased - (dev, blockNo * dev->nChunksPerBlock + i)) { + (dev, blockNo * dev->param.nChunksPerBlock + i)) { T(YAFFS_TRACE_ERROR, (TSTR (">>Block %d erasure supposedly OK, but chunk %d not erased" @@ -2843,6 +2886,7 @@ static void yaffs_BlockBecameDirty(yaffs_Device *dev, int blockNo) if (erasedOk) { /* Clean it up... */ bi->blockState = YAFFS_BLOCK_STATE_EMPTY; + bi->sequenceNumber = 0; dev->nErasedBlocks++; bi->pagesInUse = 0; bi->softDeletions = 0; @@ -2854,7 +2898,7 @@ static void yaffs_BlockBecameDirty(yaffs_Device *dev, int blockNo) T(YAFFS_TRACE_ERASE, (TSTR("Erased block %d" TENDSTR), blockNo)); } else { - dev->nFreeChunks -= dev->nChunksPerBlock; /* We lost a block of free space */ + dev->nFreeChunks -= dev->param.nChunksPerBlock; /* We lost a block of free space */ yaffs_RetireBlock(dev, blockNo); T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS, @@ -2915,17 +2959,12 @@ static int yaffs_FindBlockForAllocation(yaffs_Device *dev) static int yaffs_CalcCheckpointBlocksRequired(yaffs_Device *dev) { if (!dev->nCheckpointBlocksRequired && - dev->isYaffs2) { + dev->param.isYaffs2) { /* Not a valid value so recalculate */ int nBytes = 0; int nBlocks; - int devBlocks = (dev->endBlock - dev->startBlock + 1); - int tnodeSize; - - tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8; - - if (tnodeSize < sizeof(yaffs_Tnode)) - tnodeSize = sizeof(yaffs_Tnode); + int devBlocks = (dev->param.endBlock - dev->param.startBlock + 1); + int tnodeSize = yaffs_CalcTnodeSize(dev); nBytes += sizeof(yaffs_CheckpointValidity); nBytes += sizeof(yaffs_CheckpointDevice); @@ -2938,7 +2977,7 @@ static int yaffs_CalcCheckpointBlocksRequired(yaffs_Device *dev) /* Round up and add 2 blocks to allow for some bad blocks, so add 3 */ - nBlocks = (nBytes/(dev->nDataBytesPerChunk * dev->nChunksPerBlock)) + 3; + nBlocks = (nBytes/(dev->nDataBytesPerChunk * dev->param.nChunksPerBlock)) + 3; dev->nCheckpointBlocksRequired = nBlocks; } @@ -2950,13 +2989,13 @@ static int yaffs_CalcCheckpointBlocksRequired(yaffs_Device *dev) * Check if there's space to allocate... * Thinks.... do we need top make this ths same as yaffs_GetFreeChunks()? */ -static int yaffs_CheckSpaceForAllocation(yaffs_Device *dev) +static int yaffs_CheckSpaceForAllocation(yaffs_Device *dev, int nChunks) { int reservedChunks; - int reservedBlocks = dev->nReservedBlocks; + int reservedBlocks = dev->param.nReservedBlocks; int checkpointBlocks; - if (dev->isYaffs2) { + if (dev->param.isYaffs2) { checkpointBlocks = yaffs_CalcCheckpointBlocksRequired(dev) - dev->blocksInCheckpoint; if (checkpointBlocks < 0) @@ -2965,9 +3004,9 @@ static int yaffs_CheckSpaceForAllocation(yaffs_Device *dev) checkpointBlocks = 0; } - reservedChunks = ((reservedBlocks + checkpointBlocks) * dev->nChunksPerBlock); + reservedChunks = ((reservedBlocks + checkpointBlocks) * dev->param.nChunksPerBlock); - return (dev->nFreeChunks > reservedChunks); + return (dev->nFreeChunks > (reservedChunks + nChunks)); } static int yaffs_AllocateChunk(yaffs_Device *dev, int useReserve, @@ -2982,12 +3021,12 @@ static int yaffs_AllocateChunk(yaffs_Device *dev, int useReserve, dev->allocationPage = 0; } - if (!useReserve && !yaffs_CheckSpaceForAllocation(dev)) { + if (!useReserve && !yaffs_CheckSpaceForAllocation(dev, 1)) { /* Not enough space to allocate unless we're allowed to use the reserve. */ return -1; } - if (dev->nErasedBlocks < dev->nReservedBlocks + if (dev->nErasedBlocks < dev->param.nReservedBlocks && dev->allocationPage == 0) { T(YAFFS_TRACE_ALLOCATE, (TSTR("Allocating reserve" TENDSTR))); } @@ -2996,7 +3035,7 @@ static int yaffs_AllocateChunk(yaffs_Device *dev, int useReserve, if (dev->allocationBlock >= 0) { bi = yaffs_GetBlockInfo(dev, dev->allocationBlock); - retVal = (dev->allocationBlock * dev->nChunksPerBlock) + + retVal = (dev->allocationBlock * dev->param.nChunksPerBlock) + dev->allocationPage; bi->pagesInUse++; yaffs_SetChunkBit(dev, dev->allocationBlock, @@ -3007,7 +3046,7 @@ static int yaffs_AllocateChunk(yaffs_Device *dev, int useReserve, dev->nFreeChunks--; /* If the block is full set the state to full */ - if (dev->allocationPage >= dev->nChunksPerBlock) { + if (dev->allocationPage >= dev->param.nChunksPerBlock) { bi->blockState = YAFFS_BLOCK_STATE_FULL; dev->allocationBlock = -1; } @@ -3028,10 +3067,10 @@ static int yaffs_GetErasedChunks(yaffs_Device *dev) { int n; - n = dev->nErasedBlocks * dev->nChunksPerBlock; + n = dev->nErasedBlocks * dev->param.nChunksPerBlock; if (dev->allocationBlock > 0) - n += (dev->nChunksPerBlock - dev->allocationPage); + n += (dev->param.nChunksPerBlock - dev->allocationPage); return n; @@ -3092,13 +3131,7 @@ static int yaffs_GarbageCollectBlock(yaffs_Device *dev, int block, bi->hasShrinkHeader = 0; /* clear the flag so that the block can erase */ - /* Take off the number of soft deleted entries because - * they're going to get really deleted during GC. - */ - if(dev->gcChunk == 0) /* first time through for this block */ - dev->nFreeChunks -= bi->softDeletions; - - dev->isDoingGC = 1; + dev->gcDisable = 1; if (isCheckpointBlock || !yaffs_StillSomeChunkBits(dev, block)) { @@ -3113,12 +3146,12 @@ static int yaffs_GarbageCollectBlock(yaffs_Device *dev, int block, yaffs_VerifyBlock(dev, bi, block); - maxCopies = (wholeBlock) ? dev->nChunksPerBlock : 10; - oldChunk = block * dev->nChunksPerBlock + dev->gcChunk; + maxCopies = (wholeBlock) ? dev->param.nChunksPerBlock : 5; + oldChunk = block * dev->param.nChunksPerBlock + dev->gcChunk; for (/* init already done */; retVal == YAFFS_OK && - dev->gcChunk < dev->nChunksPerBlock && + dev->gcChunk < dev->param.nChunksPerBlock && (bi->blockState == YAFFS_BLOCK_STATE_COLLECTING) && maxCopies > 0; dev->gcChunk++, oldChunk++) { @@ -3177,6 +3210,13 @@ static int yaffs_GarbageCollectBlock(yaffs_Device *dev, int block, * No need to copy this, just forget about it and * fix up the object. */ + + /* Free chunks already includes softdeleted chunks. + * How ever this chunk is going to soon be really deleted + * which will increment free chunks. + * We have to decrement free chunks so this works out properly. + */ + dev->nFreeChunks--; object->nDataChunks--; @@ -3219,17 +3259,26 @@ static int yaffs_GarbageCollectBlock(yaffs_Device *dev, int block, yaffs_ObjectHeader *oh; oh = (yaffs_ObjectHeader *)buffer; + oh->isShrink = 0; tags.extraIsShrinkHeader = 0; + oh->shadowsObject = 0; oh->inbandShadowsObject = 0; tags.extraShadows = 0; - yaffs_VerifyObjectHeader(object, oh, &tags, 1); - } + /* Update file size */ + if(object->variantType == YAFFS_OBJECT_TYPE_FILE){ + oh->fileSize = object->variant.fileVariant.fileSize; + tags.extraFileLength = oh->fileSize; + } - newChunk = - yaffs_WriteNewChunkWithTagsToNAND(dev, buffer, &tags, 1); + yaffs_VerifyObjectHeader(object, oh, &tags, 1); + newChunk = + yaffs_WriteNewChunkWithTagsToNAND(dev,(__u8 *) oh, &tags, 1); + } else + newChunk = + yaffs_WriteNewChunkWithTagsToNAND(dev, buffer, &tags, 1); if (newChunk < 0) { retVal = YAFFS_FAIL; @@ -3243,7 +3292,8 @@ static int yaffs_GarbageCollectBlock(yaffs_Device *dev, int block, object->serial = tags.serialNumber; } else { /* It's a data chunk */ - yaffs_PutChunkIntoFile + int ok; + ok = yaffs_PutChunkIntoFile (object, tags.chunkId, newChunk, 0); @@ -3285,25 +3335,182 @@ static int yaffs_GarbageCollectBlock(yaffs_Device *dev, int block, yaffs_VerifyCollectedBlock(dev, bi, block); - chunksAfter = yaffs_GetErasedChunks(dev); - if (chunksBefore >= chunksAfter) { - T(YAFFS_TRACE_GC, - (TSTR - ("gc did not increase free chunks before %d after %d" - TENDSTR), chunksBefore, chunksAfter)); - } - /* If the gc completed then clear the current gcBlock so that we find another. */ - if (bi->blockState != YAFFS_BLOCK_STATE_COLLECTING) { - dev->gcBlock = -1; + + if (bi->blockState == YAFFS_BLOCK_STATE_COLLECTING) { + /* + * The gc did not complete. Set block state back to FULL + * because checkpointing does not restore gc. + */ + bi->blockState = YAFFS_BLOCK_STATE_FULL; + } else { + /* The gc completed. */ + chunksAfter = yaffs_GetErasedChunks(dev); + if (chunksBefore >= chunksAfter) { + T(YAFFS_TRACE_GC, + (TSTR + ("gc did not increase free chunks before %d after %d" + TENDSTR), chunksBefore, chunksAfter)); + } + dev->gcBlock = 0; dev->gcChunk = 0; } - dev->isDoingGC = 0; + dev->gcDisable = 0; return retVal; } +/* + * FindBlockForgarbageCollection is used to select the dirtiest block (or close enough) + * for garbage collection. + */ + +static unsigned yaffs_FindBlockForGarbageCollection(yaffs_Device *dev, + int aggressive, + int background) +{ + int i; + int iterations; + unsigned selected = 0; + int prioritised = 0; + int prioritisedExists = 0; + yaffs_BlockInfo *bi; + int threshold; + + /* First let's see if we need to grab a prioritised block */ + if (dev->hasPendingPrioritisedGCs && !aggressive) { + dev->gcDirtiest = 0; + bi = dev->blockInfo; + for (i = dev->internalStartBlock; + i <= dev->internalEndBlock && !selected; + i++) { + + if (bi->gcPrioritise) { + prioritisedExists = 1; + if (bi->blockState == YAFFS_BLOCK_STATE_FULL && + yaffs_BlockNotDisqualifiedFromGC(dev, bi)) { + selected = i; + prioritised = 1; + } + } + bi++; + } + + /* + * If there is a prioritised block and none was selected then + * this happened because there is at least one old dirty block gumming + * up the works. Let's gc the oldest dirty block. + */ + + if(prioritisedExists && + !selected && + dev->oldestDirtyBlock > 0) + selected = dev->oldestDirtyBlock; + + if (!prioritisedExists) /* 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. + * else (we're doing a leasurely gc), then we only bother to do this if the + * block has only a few pages in use. + */ + + if (!selected){ + int pagesUsed; + int nBlocks = dev->internalEndBlock - dev->internalStartBlock + 1; + if (aggressive){ + threshold = dev->param.nChunksPerBlock; + iterations = nBlocks; + } else { + int maxThreshold = dev->param.nChunksPerBlock/2; + threshold = background ? + (dev->gcNotDone + 2) * 2 : 0; + if(threshold maxThreshold) + threshold = maxThreshold; + + iterations = nBlocks / 16 + 1; + if (iterations > 100) + iterations = 100; + } + + for (i = 0; + i < iterations && + (dev->gcDirtiest < 1 || + dev->gcPagesInUse > YAFFS_GC_GOOD_ENOUGH); + i++) { + dev->gcBlockFinder++; + if (dev->gcBlockFinder < dev->internalStartBlock || + dev->gcBlockFinder > dev->internalEndBlock) + dev->gcBlockFinder = dev->internalStartBlock; + + bi = yaffs_GetBlockInfo(dev, dev->gcBlockFinder); + + pagesUsed = bi->pagesInUse - bi->softDeletions; + + if (bi->blockState == YAFFS_BLOCK_STATE_FULL && + pagesUsed < dev->param.nChunksPerBlock && + (dev->gcDirtiest < 1 || pagesUsed < dev->gcPagesInUse) && + yaffs_BlockNotDisqualifiedFromGC(dev, bi)) { + dev->gcDirtiest = dev->gcBlockFinder; + dev->gcPagesInUse = pagesUsed; + } + } + + if(dev->gcDirtiest > 0 && dev->gcPagesInUse <= threshold) + selected = dev->gcDirtiest; + } + + /* + * If nothing has been selected for a while, try selecting the oldest dirty + * because that's gumming up the works. + */ + + if(!selected && dev->param.isYaffs2 && + dev->gcNotDone >= ( background ? 10 : 20)){ + yaffs_FindOldestDirtySequence(dev); + if(dev->oldestDirtyBlock > 0) { + selected = dev->oldestDirtyBlock; + dev->gcDirtiest = selected; + dev->oldestDirtyGCs++; + bi = yaffs_GetBlockInfo(dev, selected); + dev->gcPagesInUse = bi->pagesInUse - bi->softDeletions; + } else + dev->gcNotDone = 0; + } + + if(selected){ + T(YAFFS_TRACE_GC, + (TSTR("GC Selected block %d with %d free, prioritised:%d" TENDSTR), + selected, + dev->param.nChunksPerBlock - dev->gcPagesInUse, + prioritised)); + + if(background) + dev->backgroundGCs++; + dev->gcDirtiest = 0; + dev->gcPagesInUse = 0; + dev->gcNotDone = 0; + if(dev->refreshSkip > 0) + dev->refreshSkip--; + } else{ + dev->gcNotDone++; + T(YAFFS_TRACE_GC, + (TSTR("GC none: finder %d skip %d threshold %d dirtiest %d using %d oldest %d%s" TENDSTR), + dev->gcBlockFinder, dev->gcNotDone, + threshold, + dev->gcDirtiest, dev->gcPagesInUse, + dev->oldestDirtyBlock, + background ? " bg" : "")); + } + + return selected; +} + /* New garbage collector * If we're very low on erased blocks then we do aggressive garbage collection * otherwise we do "leasurely" garbage collection. @@ -3313,22 +3520,28 @@ static int yaffs_GarbageCollectBlock(yaffs_Device *dev, int block, * The idea is to help clear out space in a more spread-out manner. * Dunno if it really does anything useful. */ -static int yaffs_CheckGarbageCollection(yaffs_Device *dev) +static int yaffs_CheckGarbageCollection(yaffs_Device *dev, int background) { - int block; - int aggressive; + int aggressive = 0; int gcOk = YAFFS_OK; int maxTries = 0; + int minErased; + int erasedChunks; + int checkpointBlockAdjust; - if (dev->isDoingGC) { + if(dev->param.gcControl && + (dev->param.gcControl(dev) & 1) == 0) + return YAFFS_OK; + + if (dev->gcDisable) { /* Bail out so we don't get recursive gc */ return YAFFS_OK; } /* This loop should pass the first time. - * We'll only see looping here if the erase of the collected block fails. + * We'll only see looping here if the collection does not increase space. */ do { @@ -3338,47 +3551,79 @@ static int yaffs_CheckGarbageCollection(yaffs_Device *dev) if (checkpointBlockAdjust < 0) checkpointBlockAdjust = 0; - if (dev->nErasedBlocks < (dev->nReservedBlocks + checkpointBlockAdjust + 2)) { - /* We need a block soon...*/ + minErased = dev->param.nReservedBlocks + checkpointBlockAdjust + 1; + erasedChunks = dev->nErasedBlocks * dev->param.nChunksPerBlock; + + /* If we need a block soon then do aggressive gc.*/ + if (dev->nErasedBlocks < minErased) aggressive = 1; - } else { - /* We're in no hurry */ - aggressive = 0; + else { + if(dev->gcSkip > 20) + dev->gcSkip = 20; + if(erasedChunks < dev->nFreeChunks/2 || + dev->gcSkip < 1 || + background) + aggressive = 0; + else { + dev->gcSkip--; + break; + } } - if (dev->gcBlock <= 0) { - dev->gcBlock = yaffs_FindBlockForGarbageCollection(dev, aggressive); + dev->gcSkip = 5; + + /* If we don't already have a block being gc'd then see if we should start another */ + + if (dev->gcBlock < 1 && !aggressive) { + dev->gcBlock = yaffs_FindRefreshBlock(dev); + dev->gcChunk = 0; + } + if (dev->gcBlock < 1) { + dev->gcBlock = yaffs_FindBlockForGarbageCollection(dev, aggressive, background); dev->gcChunk = 0; } - block = dev->gcBlock; - - if (block > 0) { - dev->garbageCollections++; + if (dev->gcBlock > 0) { + dev->allGCs++; if (!aggressive) - dev->passiveGarbageCollections++; + dev->passiveGCs++; T(YAFFS_TRACE_GC, (TSTR ("yaffs: GC erasedBlocks %d aggressive %d" TENDSTR), dev->nErasedBlocks, aggressive)); - gcOk = yaffs_GarbageCollectBlock(dev, block, aggressive); + gcOk = yaffs_GarbageCollectBlock(dev, dev->gcBlock, aggressive); } - if (dev->nErasedBlocks < (dev->nReservedBlocks) && block > 0) { + if (dev->nErasedBlocks < (dev->param.nReservedBlocks) && dev->gcBlock > 0) { T(YAFFS_TRACE_GC, (TSTR ("yaffs: GC !!!no reclaim!!! erasedBlocks %d after try %d block %d" - TENDSTR), dev->nErasedBlocks, maxTries, block)); + TENDSTR), dev->nErasedBlocks, maxTries, dev->gcBlock)); } - } while ((dev->nErasedBlocks < dev->nReservedBlocks) && - (block > 0) && + } while ((dev->nErasedBlocks < dev->param.nReservedBlocks) && + (dev->gcBlock > 0) && (maxTries < 2)); return aggressive ? gcOk : YAFFS_OK; } +/* + * yaffs_BackgroundGarbageCollect() + * Garbage collects. Intended to be called from a background thread. + * Returns non-zero if at least half the free chunks are erased. + */ +int yaffs_BackgroundGarbageCollect(yaffs_Device *dev, unsigned urgency) +{ + int erasedChunks = dev->nErasedBlocks * dev->param.nChunksPerBlock; + + T(YAFFS_TRACE_BACKGROUND, (TSTR("Background gc %u" TENDSTR),urgency)); + + yaffs_CheckGarbageCollection(dev, 1); + return erasedChunks > dev->nFreeChunks/2; +} + /*------------------------- TAGS --------------------------------*/ static int yaffs_TagsMatch(const yaffs_ExtendedTags *tags, int objectId, @@ -3486,8 +3731,8 @@ static int yaffs_CheckFileSanity(yaffs_Object *in) theChunk = yaffs_GetChunkGroupBase(dev, tn, chunk); if (yaffs_CheckChunkBits - (dev, theChunk / dev->nChunksPerBlock, - theChunk % dev->nChunksPerBlock)) { + (dev, theChunk / dev->param.nChunksPerBlock, + theChunk % dev->param.nChunksPerBlock)) { yaffs_ReadChunkTagsFromNAND(in->myDev, theChunk, tags, @@ -3555,7 +3800,6 @@ static int yaffs_PutChunkIntoFile(yaffs_Object *in, int chunkInInode, if(!chunkInNAND) /* Dummy insert, bail now */ return YAFFS_OK; - existingChunk = yaffs_GetChunkGroupBase(dev, tn, chunkInInode); @@ -3612,7 +3856,7 @@ static int yaffs_PutChunkIntoFile(yaffs_Object *in, int chunkInInode, } if ((inScan > 0) && - (in->myDev->isYaffs2 || + (in->myDev->param.isYaffs2 || existingChunk <= 0 || ((existingSerial + 1) & 3) == newSerial)) { /* Forward scanning. @@ -3672,8 +3916,8 @@ void yaffs_DeleteChunk(yaffs_Device *dev, int chunkId, int markNAND, int lyn) return; dev->nDeletions++; - block = chunkId / dev->nChunksPerBlock; - page = chunkId % dev->nChunksPerBlock; + block = chunkId / dev->param.nChunksPerBlock; + page = chunkId % dev->param.nChunksPerBlock; if (!yaffs_CheckChunkBit(dev, block, page)) @@ -3682,12 +3926,14 @@ void yaffs_DeleteChunk(yaffs_Device *dev, int chunkId, int markNAND, int lyn) chunkId)); bi = yaffs_GetBlockInfo(dev, block); + + yaffs_UpdateOldestDirtySequence(dev, block, bi); T(YAFFS_TRACE_DELETION, (TSTR("line %d delete of chunk %d" TENDSTR), lyn, chunkId)); if (markNAND && - bi->blockState != YAFFS_BLOCK_STATE_COLLECTING && !dev->isYaffs2) { + bi->blockState != YAFFS_BLOCK_STATE_COLLECTING && !dev->param.isYaffs2) { yaffs_InitialiseTags(&tags); @@ -3740,10 +3986,16 @@ static int yaffs_WriteChunkDataToObject(yaffs_Object *in, int chunkInInode, yaffs_Device *dev = in->myDev; - yaffs_CheckGarbageCollection(dev); + yaffs_CheckGarbageCollection(dev,0); - /* Get the previous chunk at this location in the file if it exists */ + /* Get the previous chunk at this location in the file if it exists. + * If it does not exist then put a zero into the tree. This creates + * the tnode now, rather than later when it is harder to clean up. + */ prevChunkId = yaffs_FindChunkInFile(in, chunkInInode, &prevTags); + if(prevChunkId < 1 && + !yaffs_PutChunkIntoFile(in, chunkInInode, 0, 0)) + return 0; /* Set up new tags */ yaffs_InitialiseTags(&newTags); @@ -3754,19 +4006,12 @@ static int yaffs_WriteChunkDataToObject(yaffs_Object *in, int chunkInInode, (prevChunkId > 0) ? prevTags.serialNumber + 1 : 1; newTags.byteCount = nBytes; - if (nBytes < 1 || nBytes > dev->totalBytesPerChunk) { + if (nBytes < 1 || nBytes > dev->param.totalBytesPerChunk) { T(YAFFS_TRACE_ERROR, (TSTR("Writing %d bytes to chunk!!!!!!!!!" TENDSTR), nBytes)); YBUG(); } - /* - * If there isn't already a chunk there then do a dummy - * insert to make sue we have the desired tnode structure. - */ - if(prevChunkId < 1 && - yaffs_PutChunkIntoFile(in, chunkInInode, 0, 0) != YAFFS_OK) - return -1; newChunkId = yaffs_WriteNewChunkWithTagsToNAND(dev, buffer, &newTags, @@ -3816,7 +4061,7 @@ int yaffs_UpdateObjectHeader(yaffs_Object *in, const YCHAR *name, int force, in == dev->rootDir || /* The rootDir should also be saved */ force) { - yaffs_CheckGarbageCollection(dev); + yaffs_CheckGarbageCollection(dev,0); yaffs_CheckObjectDetailsLoaded(in); buffer = yaffs_GetTempBuffer(in->myDev, __LINE__); @@ -3940,7 +4185,7 @@ int yaffs_UpdateObjectHeader(yaffs_Object *in, const YCHAR *name, int force, /* If this was a shrink, then mark the block that the chunk lives on */ if (isShrink) { bi = yaffs_GetBlockInfo(in->myDev, - newChunkId / in->myDev->nChunksPerBlock); + newChunkId / in->myDev->param.nChunksPerBlock); bi->hasShrinkHeader = 1; } @@ -3974,7 +4219,7 @@ static int yaffs_ObjectHasCachedWriteData(yaffs_Object *obj) yaffs_Device *dev = obj->myDev; int i; yaffs_ChunkCache *cache; - int nCaches = obj->myDev->nShortOpCaches; + int nCaches = obj->myDev->param.nShortOpCaches; for (i = 0; i < nCaches; i++) { cache = &dev->srCache[i]; @@ -3994,7 +4239,7 @@ static void yaffs_FlushFilesChunkCache(yaffs_Object *obj) int i; yaffs_ChunkCache *cache; int chunkWritten = 0; - int nCaches = obj->myDev->nShortOpCaches; + int nCaches = obj->myDev->param.nShortOpCaches; if (nCaches > 0) { do { @@ -4046,7 +4291,7 @@ static void yaffs_FlushFilesChunkCache(yaffs_Object *obj) void yaffs_FlushEntireDeviceCache(yaffs_Device *dev) { yaffs_Object *obj; - int nCaches = dev->nShortOpCaches; + int nCaches = dev->param.nShortOpCaches; int i; /* Find a dirty object in the cache and flush it... @@ -4077,8 +4322,8 @@ static yaffs_ChunkCache *yaffs_GrabChunkCacheWorker(yaffs_Device *dev) { int i; - if (dev->nShortOpCaches > 0) { - for (i = 0; i < dev->nShortOpCaches; i++) { + if (dev->param.nShortOpCaches > 0) { + for (i = 0; i < dev->param.nShortOpCaches; i++) { if (!dev->srCache[i].object) return &dev->srCache[i]; } @@ -4095,7 +4340,7 @@ static yaffs_ChunkCache *yaffs_GrabChunkCache(yaffs_Device *dev) int i; int pushout; - if (dev->nShortOpCaches > 0) { + if (dev->param.nShortOpCaches > 0) { /* Try find a non-dirty one... */ cache = yaffs_GrabChunkCacheWorker(dev); @@ -4114,7 +4359,7 @@ static yaffs_ChunkCache *yaffs_GrabChunkCache(yaffs_Device *dev) cache = NULL; pushout = -1; - for (i = 0; i < dev->nShortOpCaches; i++) { + for (i = 0; i < dev->param.nShortOpCaches; i++) { if (dev->srCache[i].object && !dev->srCache[i].locked && (dev->srCache[i].lastUse < usage || !cache)) { @@ -4144,8 +4389,8 @@ static yaffs_ChunkCache *yaffs_FindChunkCache(const yaffs_Object *obj, { yaffs_Device *dev = obj->myDev; int i; - if (dev->nShortOpCaches > 0) { - for (i = 0; i < dev->nShortOpCaches; i++) { + if (dev->param.nShortOpCaches > 0) { + for (i = 0; i < dev->param.nShortOpCaches; i++) { if (dev->srCache[i].object == obj && dev->srCache[i].chunkId == chunkId) { dev->cacheHits++; @@ -4162,11 +4407,11 @@ static void yaffs_UseChunkCache(yaffs_Device *dev, yaffs_ChunkCache *cache, int isAWrite) { - if (dev->nShortOpCaches > 0) { + if (dev->param.nShortOpCaches > 0) { if (dev->srLastUse < 0 || dev->srLastUse > 100000000) { /* Reset the cache usages */ int i; - for (i = 1; i < dev->nShortOpCaches; i++) + for (i = 1; i < dev->param.nShortOpCaches; i++) dev->srCache[i].lastUse = 0; dev->srLastUse = 0; @@ -4187,7 +4432,7 @@ static void yaffs_UseChunkCache(yaffs_Device *dev, yaffs_ChunkCache *cache, */ static void yaffs_InvalidateChunkCache(yaffs_Object *object, int chunkId) { - if (object->myDev->nShortOpCaches > 0) { + if (object->myDev->param.nShortOpCaches > 0) { yaffs_ChunkCache *cache = yaffs_FindChunkCache(object, chunkId); if (cache) @@ -4203,9 +4448,9 @@ static void yaffs_InvalidateWholeChunkCache(yaffs_Object *in) int i; yaffs_Device *dev = in->myDev; - if (dev->nShortOpCaches > 0) { + if (dev->param.nShortOpCaches > 0) { /* Invalidate it. */ - for (i = 0; i < dev->nShortOpCaches; i++) { + for (i = 0; i < dev->param.nShortOpCaches; i++) { if (dev->srCache[i].object == in) dev->srCache[i].object = NULL; } @@ -4257,7 +4502,6 @@ static void yaffs_DeviceToCheckpointDevice(yaffs_CheckpointDevice *cp, cp->nUnlinkedFiles = dev->nUnlinkedFiles; cp->nBackgroundDeletions = dev->nBackgroundDeletions; cp->sequenceNumber = dev->sequenceNumber; - cp->oldestDirtySequence = dev->oldestDirtySequence; } @@ -4273,7 +4517,6 @@ static void yaffs_CheckpointDeviceToDevice(yaffs_Device *dev, dev->nUnlinkedFiles = cp->nUnlinkedFiles; dev->nBackgroundDeletions = cp->nBackgroundDeletions; dev->sequenceNumber = cp->sequenceNumber; - dev->oldestDirtySequence = cp->oldestDirtySequence; } @@ -4424,11 +4667,7 @@ static int yaffs_CheckpointTnodeWorker(yaffs_Object *in, yaffs_Tnode *tn, int i; yaffs_Device *dev = in->myDev; int ok = 1; - int tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8; - - if (tnodeSize < sizeof(yaffs_Tnode)) - tnodeSize = sizeof(yaffs_Tnode); - + int tnodeSize = yaffs_CalcTnodeSize(dev); if (tn) { if (level > 0) { @@ -4479,10 +4718,7 @@ static int yaffs_ReadCheckpointTnodes(yaffs_Object *obj) yaffs_FileStructure *fileStructPtr = &obj->variant.fileVariant; yaffs_Tnode *tn; int nread = 0; - int tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8; - - if (tnodeSize < sizeof(yaffs_Tnode)) - tnodeSize = sizeof(yaffs_Tnode); + int tnodeSize = yaffs_CalcTnodeSize(dev); ok = (yaffs_CheckpointRead(dev, &baseChunk, sizeof(baseChunk)) == sizeof(baseChunk)); @@ -4644,7 +4880,7 @@ static int yaffs_WriteCheckpointData(yaffs_Device *dev) { int ok = 1; - if (dev->skipCheckpointWrite || !dev->isYaffs2) { + if (dev->param.skipCheckpointWrite || !dev->param.isYaffs2) { T(YAFFS_TRACE_CHECKPOINT, (TSTR("skipping checkpoint write" TENDSTR))); ok = 0; } @@ -4687,7 +4923,7 @@ static int yaffs_ReadCheckpointData(yaffs_Device *dev) { int ok = 1; - if (dev->skipCheckpointRead || !dev->isYaffs2) { + if (dev->param.skipCheckpointRead || !dev->param.isYaffs2) { T(YAFFS_TRACE_CHECKPOINT, (TSTR("skipping checkpoint read" TENDSTR))); ok = 0; } @@ -4735,9 +4971,9 @@ static void yaffs_InvalidateCheckpoint(yaffs_Device *dev) dev->blocksInCheckpoint > 0) { dev->isCheckpointed = 0; yaffs_CheckpointInvalidateStream(dev); - if (dev->superBlock && dev->markSuperBlockDirty) - dev->markSuperBlockDirty(dev->superBlock); } + if (dev->param.markSuperBlockDirty) + dev->param.markSuperBlockDirty(dev); } @@ -4823,8 +5059,8 @@ int yaffs_ReadDataFromFile(yaffs_Object *in, __u8 *buffer, loff_t offset, * or we're using inband tags then use the cache (if there is caching) * else bypass the cache. */ - if (cache || nToCopy != dev->nDataBytesPerChunk || dev->inbandTags) { - if (dev->nShortOpCaches > 0) { + if (cache || nToCopy != dev->nDataBytesPerChunk || dev->param.inbandTags) { + if (dev->param.nShortOpCaches > 0) { /* If we can't find the data in the cache, then load it up. */ @@ -4880,7 +5116,7 @@ int yaffs_ReadDataFromFile(yaffs_Object *in, __u8 *buffer, loff_t offset, return nDone; } -int yaffs_WriteDataToFile(yaffs_Object *in, const __u8 *buffer, loff_t offset, +int yaffs_DoWriteDataToFile(yaffs_Object *in, const __u8 *buffer, loff_t offset, int nBytes, int writeThrough) { @@ -4947,29 +5183,27 @@ int yaffs_WriteDataToFile(yaffs_Object *in, const __u8 *buffer, loff_t offset, nToWriteBack = dev->nDataBytesPerChunk; } - if (nToCopy != dev->nDataBytesPerChunk || dev->inbandTags) { + if (nToCopy != dev->nDataBytesPerChunk || dev->param.inbandTags) { /* An incomplete start or end chunk (or maybe both start and end chunk), * or we're using inband tags, so we want to use the cache buffers. */ - if (dev->nShortOpCaches > 0) { + if (dev->param.nShortOpCaches > 0) { yaffs_ChunkCache *cache; /* If we can't find the data in the cache, then load the cache */ cache = yaffs_FindChunkCache(in, chunk); if (!cache - && yaffs_CheckSpaceForAllocation(in-> - myDev)) { - cache = yaffs_GrabChunkCache(in->myDev); + && yaffs_CheckSpaceForAllocation(dev, 1)) { + cache = yaffs_GrabChunkCache(dev); cache->object = in; cache->chunkId = chunk; cache->dirty = 0; cache->locked = 0; yaffs_ReadChunkDataFromObject(in, chunk, - cache-> - data); + cache->data); } else if (cache && !cache->dirty && - !yaffs_CheckSpaceForAllocation(in->myDev)) { + !yaffs_CheckSpaceForAllocation(dev, 1)) { /* Drop the cache if it was a read cache item and * no space check has been made for it. */ @@ -5060,6 +5294,14 @@ int yaffs_WriteDataToFile(yaffs_Object *in, const __u8 *buffer, loff_t offset, return nDone; } +int yaffs_WriteDataToFile(yaffs_Object *in, const __u8 *buffer, loff_t offset, + int nBytes, int writeThrough) +{ + yaffs_HandleHole(in,offset); + return yaffs_DoWriteDataToFile(in,buffer,offset,nBytes,writeThrough); +} + + /* ---------------------- File resizing stuff ------------------ */ @@ -5088,10 +5330,10 @@ static void yaffs_PruneResizedChunks(yaffs_Object *in, int newSize) chunkId = yaffs_FindAndDeleteChunkInFile(in, i, NULL); if (chunkId > 0) { if (chunkId < - (dev->internalStartBlock * dev->nChunksPerBlock) + (dev->internalStartBlock * dev->param.nChunksPerBlock) || chunkId >= ((dev->internalEndBlock + - 1) * dev->nChunksPerBlock)) { + 1) * dev->param.nChunksPerBlock)) { T(YAFFS_TRACE_ALWAYS, (TSTR("Found daft chunkId %d for %d" TENDSTR), chunkId, i)); @@ -5104,58 +5346,146 @@ static void yaffs_PruneResizedChunks(yaffs_Object *in, int newSize) } -int yaffs_ResizeFile(yaffs_Object *in, loff_t newSize) -{ - int oldFileSize = in->variant.fileVariant.fileSize; - __u32 newSizeOfPartialChunk; +static void yaffs_ResizeDown( yaffs_Object *obj, loff_t newSize) +{ int newFullChunks; - - yaffs_Device *dev = in->myDev; + __u32 newSizeOfPartialChunk; + yaffs_Device *dev = obj->myDev; yaffs_AddrToChunk(dev, newSize, &newFullChunks, &newSizeOfPartialChunk); - yaffs_FlushFilesChunkCache(in); - yaffs_InvalidateWholeChunkCache(in); + yaffs_PruneResizedChunks(obj, newSize); - yaffs_CheckGarbageCollection(dev); + if (newSizeOfPartialChunk != 0) { + int lastChunk = 1 + newFullChunks; + __u8 *localBuffer = yaffs_GetTempBuffer(dev, __LINE__); - if (in->variantType != YAFFS_OBJECT_TYPE_FILE) - return YAFFS_FAIL; + /* Got to read and rewrite the last chunk with its new size and zero pad */ + yaffs_ReadChunkDataFromObject(obj, lastChunk, localBuffer); + memset(localBuffer + newSizeOfPartialChunk, 0, + dev->nDataBytesPerChunk - newSizeOfPartialChunk); - if (newSize == oldFileSize) - return YAFFS_OK; + yaffs_WriteChunkDataToObject(obj, lastChunk, localBuffer, + newSizeOfPartialChunk, 1); - if (newSize < oldFileSize) { + yaffs_ReleaseTempBuffer(dev, localBuffer, __LINE__); + } + + obj->variant.fileVariant.fileSize = newSize; + + yaffs_PruneFileStructure(dev, &obj->variant.fileVariant); +} + + +static int yaffs_HandleHole(yaffs_Object *obj, loff_t newSize) +{ + /* if newsSize > oldFileSize. + * We're going to be writing a hole. + * If the hole is small then write zeros otherwise write a start of hole marker. + */ + - yaffs_PruneResizedChunks(in, newSize); + loff_t oldFileSize; + int increase; + int smallHole ; + int result = YAFFS_OK; + yaffs_Device *dev = NULL; + + __u8 *localBuffer = NULL; + + int smallIncreaseOk = 0; + + if(!obj) + return YAFFS_FAIL; - if (newSizeOfPartialChunk != 0) { - int lastChunk = 1 + newFullChunks; + if(obj->variantType != YAFFS_OBJECT_TYPE_FILE) + return YAFFS_FAIL; + + dev = obj->myDev; + + /* Bail out if not yaffs2 mode */ + if(!dev->param.isYaffs2) + return YAFFS_OK; - __u8 *localBuffer = yaffs_GetTempBuffer(dev, __LINE__); + oldFileSize = obj->variant.fileVariant.fileSize; - /* Got to read and rewrite the last chunk with its new size and zero pad */ - yaffs_ReadChunkDataFromObject(in, lastChunk, - localBuffer); + if (newSize <= oldFileSize) + return YAFFS_OK; - memset(localBuffer + newSizeOfPartialChunk, 0, - dev->nDataBytesPerChunk - newSizeOfPartialChunk); + increase = newSize - oldFileSize; - yaffs_WriteChunkDataToObject(in, lastChunk, localBuffer, - newSizeOfPartialChunk, 1); + if(increase < YAFFS_SMALL_HOLE_THRESHOLD * dev->nDataBytesPerChunk && + yaffs_CheckSpaceForAllocation(dev, YAFFS_SMALL_HOLE_THRESHOLD + 1)) + smallHole = 1; + else + smallHole = 0; - yaffs_ReleaseTempBuffer(dev, localBuffer, __LINE__); + if(smallHole) + localBuffer= yaffs_GetTempBuffer(dev, __LINE__); + + if(localBuffer){ + /* fill hole with zero bytes */ + int pos = oldFileSize; + int thisWrite; + int written; + memset(localBuffer,0,dev->nDataBytesPerChunk); + smallIncreaseOk = 1; + + while(increase > 0 && smallIncreaseOk){ + thisWrite = increase; + if(thisWrite > dev->nDataBytesPerChunk) + thisWrite = dev->nDataBytesPerChunk; + written = yaffs_DoWriteDataToFile(obj,localBuffer,pos,thisWrite,0); + if(written == thisWrite){ + pos += thisWrite; + increase -= thisWrite; + } else + smallIncreaseOk = 0; } - in->variant.fileVariant.fileSize = newSize; + yaffs_ReleaseTempBuffer(dev,localBuffer,__LINE__); - yaffs_PruneFileStructure(dev, &in->variant.fileVariant); - } else { - /* newsSize > oldFileSize */ - in->variant.fileVariant.fileSize = newSize; + /* If we were out of space then reverse any chunks we've added */ + if(!smallIncreaseOk) + yaffs_ResizeDown(obj, oldFileSize); + } + + if (!smallIncreaseOk && + obj->parent && + obj->parent->objectId != YAFFS_OBJECTID_UNLINKED && + obj->parent->objectId != YAFFS_OBJECTID_DELETED){ + /* Write a hole start header with the old file size */ + yaffs_UpdateObjectHeader(obj, NULL, 0,1,0); } + return result; + +} + +int yaffs_ResizeFile(yaffs_Object *in, loff_t newSize) +{ + yaffs_Device *dev = in->myDev; + int oldFileSize = in->variant.fileVariant.fileSize; + + yaffs_FlushFilesChunkCache(in); + yaffs_InvalidateWholeChunkCache(in); + + yaffs_CheckGarbageCollection(dev,0); + + if (in->variantType != YAFFS_OBJECT_TYPE_FILE) + return YAFFS_FAIL; + + if (newSize == oldFileSize) + return YAFFS_OK; + + if(newSize > oldFileSize){ + yaffs_HandleHole(in,newSize); + in->variant.fileVariant.fileSize = newSize; + } else { + /* newSize < oldFileSize */ + yaffs_ResizeDown(in, newSize); + } /* Write a new object header to reflect the resize. * show we've shrunk the file, if need be @@ -5166,8 +5496,8 @@ int yaffs_ResizeFile(yaffs_Object *in, loff_t newSize) !in->isShadowed && in->parent->objectId != YAFFS_OBJECTID_UNLINKED && in->parent->objectId != YAFFS_OBJECTID_DELETED) - yaffs_UpdateObjectHeader(in, NULL, 0, - (newSize < oldFileSize) ? 1 : 0, 0); + yaffs_UpdateObjectHeader(in, NULL, 0,0,0); + return YAFFS_OK; } @@ -5227,7 +5557,7 @@ static int yaffs_DoGenericObjectDeletion(yaffs_Object *in) /* First off, invalidate the file's data in the cache, without flushing. */ yaffs_InvalidateWholeChunkCache(in); - if (in->myDev->isYaffs2 && (in->parent != in->myDev->deletedDir)) { + if (in->myDev->param.isYaffs2 && (in->parent != in->myDev->deletedDir)) { /* Move to the unlinked directory so we have a record that it was deleted. */ yaffs_ChangeObjectName(in, in->myDev->deletedDir, _Y("deleted"), 0, 0); @@ -5251,14 +5581,10 @@ static int yaffs_UnlinkFileIfNeeded(yaffs_Object *in) int retVal; int immediateDeletion = 0; + yaffs_Device *dev = in->myDev; -#ifdef __KERNEL__ if (!in->myInode) immediateDeletion = 1; -#else - if (in->inUse <= 0) - immediateDeletion = 1; -#endif if (immediateDeletion) { retVal = @@ -5269,7 +5595,7 @@ static int yaffs_UnlinkFileIfNeeded(yaffs_Object *in) in->objectId)); in->deleted = 1; in->myDev->nDeletedFiles++; - if (1 || in->myDev->isYaffs2) + if (dev->param.disableSoftDelete || dev->param.isYaffs2) yaffs_ResizeFile(in, 0); yaffs_SoftDeleteFile(in); } else { @@ -5286,8 +5612,10 @@ int yaffs_DeleteFile(yaffs_Object *in) { int retVal = YAFFS_OK; int deleted = in->deleted; + yaffs_Device *dev = in->myDev; - yaffs_ResizeFile(in, 0); + if (dev->param.disableSoftDelete || dev->param.isYaffs2) + yaffs_ResizeFile(in, 0); if (in->nDataChunks > 0) { /* Use soft deletion if there is data in the file. @@ -5354,6 +5682,10 @@ int retVal = -1; retVal = yaffs_DeleteFile(obj); break; case YAFFS_OBJECT_TYPE_DIRECTORY: + if(!ylist_empty(&obj->variant.directoryVariant.dirty)){ + T(YAFFS_TRACE_BACKGROUND, (TSTR("Remove object %d from dirty directories" TENDSTR),obj->objectId)); + ylist_del_init(&obj->variant.directoryVariant.dirty); + } return yaffs_DeleteDirectory(obj); break; case YAFFS_OBJECT_TYPE_SYMLINK: @@ -5378,13 +5710,8 @@ static int yaffs_UnlinkWorker(yaffs_Object *obj) int immediateDeletion = 0; -#ifdef __KERNEL__ if (!obj->myInode) immediateDeletion = 1; -#else - if (obj->inUse <= 0) - immediateDeletion = 1; -#endif if(obj) yaffs_UpdateParent(obj->parent); @@ -5401,23 +5728,26 @@ static int yaffs_UnlinkWorker(yaffs_Object *obj) * Instead, we do the following: * - Select a hardlink. * - Unhook it from the hard links - * - Unhook it from its parent directory (so that the rename can work) + * - Move it from its parent directory (so that the rename can work) * - Rename the object to the hardlink's name. * - Delete the hardlink */ yaffs_Object *hl; + yaffs_Object *parent; int retVal; YCHAR name[YAFFS_MAX_NAME_LENGTH + 1]; hl = ylist_entry(obj->hardLinks.next, yaffs_Object, hardLinks); + yaffs_GetObjectName(hl, name, YAFFS_MAX_NAME_LENGTH + 1); + parent = hl->parent; + ylist_del_init(&hl->hardLinks); - ylist_del_init(&hl->siblings); - yaffs_GetObjectName(hl, name, YAFFS_MAX_NAME_LENGTH + 1); + yaffs_AddObjectToDirectory(obj->myDev->unlinkedDir, hl); - retVal = yaffs_ChangeObjectName(obj, hl->parent, name, 0, 0); + retVal = yaffs_ChangeObjectName(obj,parent, name, 0, 0); if (retVal == YAFFS_OK) retVal = yaffs_DoGenericObjectDeletion(hl); @@ -5430,6 +5760,7 @@ static int yaffs_UnlinkWorker(yaffs_Object *obj) return yaffs_DeleteFile(obj); break; case YAFFS_OBJECT_TYPE_DIRECTORY: + ylist_del_init(&obj->variant.directoryVariant.dirty); return yaffs_DeleteDirectory(obj); break; case YAFFS_OBJECT_TYPE_SYMLINK: @@ -5747,8 +6078,8 @@ static int yaffs_Scan(yaffs_Device *dev) dev->sequenceNumber = YAFFS_LOWEST_SEQUENCE_NUMBER; /* Scan all the blocks to determine their state */ + bi = dev->blockInfo; for (blk = dev->internalStartBlock; blk <= dev->internalEndBlock; blk++) { - bi = yaffs_GetBlockInfo(dev, blk); yaffs_ClearChunkBits(dev, blk); bi->pagesInUse = 0; bi->softDeletions = 0; @@ -5772,8 +6103,9 @@ static int yaffs_Scan(yaffs_Device *dev) T(YAFFS_TRACE_SCAN_DEBUG, (TSTR("Block empty " TENDSTR))); dev->nErasedBlocks++; - dev->nFreeChunks += dev->nChunksPerBlock; + dev->nFreeChunks += dev->param.nChunksPerBlock; } + bi++; } startIterator = dev->internalStartBlock; @@ -5795,10 +6127,10 @@ static int yaffs_Scan(yaffs_Device *dev) deleted = 0; /* For each chunk in each block that needs scanning....*/ - for (c = 0; !alloc_failed && c < dev->nChunksPerBlock && + for (c = 0; !alloc_failed && c < dev->param.nChunksPerBlock && state == YAFFS_BLOCK_STATE_NEEDS_SCANNING; c++) { /* Read the tags and decide what to do */ - chunk = blk * dev->nChunksPerBlock + c; + chunk = blk * dev->param.nChunksPerBlock + c; result = yaffs_ReadChunkWithTagsFromNAND(dev, chunk, NULL, &tags); @@ -5836,7 +6168,7 @@ static int yaffs_Scan(yaffs_Device *dev) } - dev->nFreeChunks += (dev->nChunksPerBlock - c); + dev->nFreeChunks += (dev->param.nChunksPerBlock - c); } else if (tags.chunkId > 0) { /* chunkId > 0 so it is a data chunk... */ unsigned int endpos; @@ -5869,7 +6201,7 @@ static int yaffs_Scan(yaffs_Device *dev) endpos) { in->variant.fileVariant. scannedFileSize = endpos; - if (!dev->useHeaderFileSize) { + if (!dev->param.useHeaderFileSize) { in->variant.fileVariant. fileSize = in->variant.fileVariant. @@ -6048,7 +6380,7 @@ static int yaffs_Scan(yaffs_Device *dev) /* Todo got a problem */ break; case YAFFS_OBJECT_TYPE_FILE: - if (dev->useHeaderFileSize) + if (dev->param.useHeaderFileSize) in->variant.fileVariant. fileSize = @@ -6239,7 +6571,7 @@ static int yaffs_ScanBackwards(yaffs_Device *dev) yaffs_BlockIndex *blockIndex = NULL; int altBlockIndex = 0; - if (!dev->isYaffs2) { + if (!dev->param.isYaffs2) { T(YAFFS_TRACE_SCAN, (TSTR("yaffs_ScanBackwards is only for YAFFS2!" TENDSTR))); return YAFFS_FAIL; @@ -6271,8 +6603,8 @@ static int yaffs_ScanBackwards(yaffs_Device *dev) chunkData = yaffs_GetTempBuffer(dev, __LINE__); /* Scan all the blocks to determine their state */ + bi = dev->blockInfo; for (blk = dev->internalStartBlock; blk <= dev->internalEndBlock; blk++) { - bi = yaffs_GetBlockInfo(dev, blk); yaffs_ClearChunkBits(dev, blk); bi->pagesInUse = 0; bi->softDeletions = 0; @@ -6302,7 +6634,7 @@ static int yaffs_ScanBackwards(yaffs_Device *dev) T(YAFFS_TRACE_SCAN_DEBUG, (TSTR("Block empty " TENDSTR))); dev->nErasedBlocks++; - dev->nFreeChunks += dev->nChunksPerBlock; + dev->nFreeChunks += dev->param.nChunksPerBlock; } else if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING) { /* Determine the highest sequence number */ @@ -6325,6 +6657,7 @@ static int yaffs_ScanBackwards(yaffs_Device *dev) } } + bi++; } T(YAFFS_TRACE_SCAN, @@ -6387,7 +6720,7 @@ static int yaffs_ScanBackwards(yaffs_Device *dev) /* For each chunk in each block that needs scanning.... */ foundChunksInBlock = 0; - for (c = dev->nChunksPerBlock - 1; + for (c = dev->param.nChunksPerBlock - 1; !alloc_failed && c >= 0 && (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING || state == YAFFS_BLOCK_STATE_ALLOCATING); c--) { @@ -6395,7 +6728,7 @@ static int yaffs_ScanBackwards(yaffs_Device *dev) * Read the tags and decide what to do */ - chunk = blk * dev->nChunksPerBlock + c; + chunk = blk * dev->param.nChunksPerBlock + c; result = yaffs_ReadChunkWithTagsFromNAND(dev, chunk, NULL, &tags); @@ -6438,7 +6771,7 @@ static int yaffs_ScanBackwards(yaffs_Device *dev) * the current allocation block. */ - T(YAFFS_TRACE_ALWAYS, + T(YAFFS_TRACE_SCAN, (TSTR("Partially written block %d detected" TENDSTR), blk)); } @@ -6477,35 +6810,26 @@ static int yaffs_ScanBackwards(yaffs_Device *dev) if (in && in->variantType == YAFFS_OBJECT_TYPE_FILE - && chunkBase < - in->variant.fileVariant.shrinkSize) { + && chunkBase < in->variant.fileVariant.shrinkSize) { /* This has not been invalidated by a resize */ - if (!yaffs_PutChunkIntoFile(in, tags.chunkId, - chunk, -1)) { + if (!yaffs_PutChunkIntoFile(in, tags.chunkId, chunk, -1)) { alloc_failed = 1; } /* File size is calculated by looking at the data chunks if we have not * seen an object header yet. Stop this practice once we find an object header. */ - endpos = - (tags.chunkId - - 1) * dev->nDataBytesPerChunk + - tags.byteCount; + endpos = chunkBase + tags.byteCount; if (!in->valid && /* have not got an object header yet */ - in->variant.fileVariant. - scannedFileSize < endpos) { - in->variant.fileVariant. - scannedFileSize = endpos; - in->variant.fileVariant. - fileSize = - in->variant.fileVariant. - scannedFileSize; + in->variant.fileVariant.scannedFileSize < endpos) { + in->variant.fileVariant.scannedFileSize = endpos; + in->variant.fileVariant.fileSize = endpos; } } else if (in) { - /* This chunk has been invalidated by a resize, so delete */ + /* This chunk has been invalidated by a resize, or a past file deletion + * so delete the chunk*/ yaffs_DeleteChunk(dev, chunk, 1, __LINE__); } @@ -6522,15 +6846,15 @@ static int yaffs_ScanBackwards(yaffs_Device *dev) in = NULL; if (tags.extraHeaderInfoAvailable) { - in = yaffs_FindOrCreateObjectByNumber - (dev, tags.objectId, - tags.extraObjectType); + in = yaffs_FindOrCreateObjectByNumber(dev, + tags.objectId, + tags.extraObjectType); if (!in) alloc_failed = 1; } if (!in || - (!in->valid && dev->disableLazyLoad) || + (!in->valid && dev->param.disableLazyLoad) || tags.extraShadows || (!in->valid && (tags.objectId == YAFFS_OBJECTID_ROOT || @@ -6548,7 +6872,7 @@ static int yaffs_ScanBackwards(yaffs_Device *dev) oh = (yaffs_ObjectHeader *) chunkData; - if (dev->inbandTags) { + if (dev->param.inbandTags) { /* Fix up the header if they got corrupted by inband tags */ oh->shadowsObject = oh->inbandShadowsObject; oh->isShrink = oh->inbandIsShrink; @@ -6606,13 +6930,8 @@ static int yaffs_ScanBackwards(yaffs_Device *dev) isShrink = 1; } - if (isShrink && - in->variant.fileVariant. - shrinkSize > thisSize) { - in->variant.fileVariant. - shrinkSize = - thisSize; - } + if (isShrink && in->variant.fileVariant.shrinkSize > thisSize) + in->variant.fileVariant.shrinkSize = thisSize; if (isShrink) bi->hasShrinkHeader = 1; @@ -6785,14 +7104,12 @@ static int yaffs_ScanBackwards(yaffs_Device *dev) * than its current data extents. */ in->variant.fileVariant.fileSize = fileSize; - in->variant.fileVariant.scannedFileSize = - in->variant.fileVariant.fileSize; + in->variant.fileVariant.scannedFileSize = fileSize; } - if (isShrink && - in->variant.fileVariant.shrinkSize > fileSize) { + if (in->variant.fileVariant.shrinkSize > fileSize) in->variant.fileVariant.shrinkSize = fileSize; - } + break; case YAFFS_OBJECT_TYPE_HARDLINK: @@ -6954,17 +7271,57 @@ static void yaffs_VerifyDirectory(yaffs_Object *directory) * create dir/a : update dir's mtime/ctime * rm dir/a: update dir's mtime/ctime * modify dir/a: don't update dir's mtimme/ctime + * + * This can be handled immediately or defered. Defering helps reduce the number + * of updates when many files in a directory are changed within a brief period. + * + * If the directory updating is defered then yaffs_UpdateDirtyDirecories must be + * called periodically. */ static void yaffs_UpdateParent(yaffs_Object *obj) { + yaffs_Device *dev; if(!obj) return; + dev = obj->myDev; obj->dirty = 1; obj->yst_mtime = obj->yst_ctime = Y_CURRENT_TIME; + if(dev->param.deferDirectoryUpdate){ + struct ylist_head *link = &obj->variant.directoryVariant.dirty; + + if(ylist_empty(link)){ + ylist_add(link,&dev->dirtyDirectories); + T(YAFFS_TRACE_BACKGROUND, (TSTR("Added object %d to dirty directories" TENDSTR),obj->objectId)); + } - yaffs_UpdateObjectHeader(obj,NULL,0,0,0); + } else + yaffs_UpdateObjectHeader(obj,NULL,0,0,0); +} + +void yaffs_UpdateDirtyDirectories(yaffs_Device *dev) +{ + struct ylist_head *link; + yaffs_Object *obj; + yaffs_DirectoryStructure *dS; + yaffs_ObjectVariant *oV; + + T(YAFFS_TRACE_BACKGROUND, (TSTR("Update dirty directories" TENDSTR))); + + while(!ylist_empty(&dev->dirtyDirectories)){ + link = dev->dirtyDirectories.next; + ylist_del_init(link); + + dS=ylist_entry(link,yaffs_DirectoryStructure,dirty); + oV = ylist_entry(dS,yaffs_ObjectVariant,directoryVariant); + obj = ylist_entry(oV,yaffs_Object,variant); + + T(YAFFS_TRACE_BACKGROUND, (TSTR("Update directory %d" TENDSTR), obj->objectId)); + + if(obj->dirty) + yaffs_UpdateObjectHeader(obj,NULL,0,0,0); + } } static void yaffs_RemoveObjectFromDirectory(yaffs_Object *obj) @@ -6977,8 +7334,8 @@ static void yaffs_RemoveObjectFromDirectory(yaffs_Object *obj) yaffs_VerifyDirectory(parent); - if (dev && dev->removeObjectCallback) - dev->removeObjectCallback(obj); + if (dev && dev->param.removeObjectCallback) + dev->param.removeObjectCallback(obj); ylist_del_init(&obj->siblings); @@ -7352,30 +7709,32 @@ static int yaffs_CheckDevFunctions(const yaffs_Device *dev) { /* Common functions, gotta have */ - if (!dev->eraseBlockInNAND || !dev->initialiseNAND) + if (!dev->param.eraseBlockInNAND || !dev->param.initialiseNAND) return 0; #ifdef CONFIG_YAFFS_YAFFS2 /* Can use the "with tags" style interface for yaffs1 or yaffs2 */ - if (dev->writeChunkWithTagsToNAND && - dev->readChunkWithTagsFromNAND && - !dev->writeChunkToNAND && - !dev->readChunkFromNAND && - dev->markNANDBlockBad && dev->queryNANDBlock) + if (dev->param.writeChunkWithTagsToNAND && + dev->param.readChunkWithTagsFromNAND && + !dev->param.writeChunkToNAND && + !dev->param.readChunkFromNAND && + dev->param.markNANDBlockBad && + dev->param.queryNANDBlock) return 1; #endif /* Can use the "spare" style interface for yaffs1 */ - if (!dev->isYaffs2 && - !dev->writeChunkWithTagsToNAND && - !dev->readChunkWithTagsFromNAND && - dev->writeChunkToNAND && - dev->readChunkFromNAND && - !dev->markNANDBlockBad && !dev->queryNANDBlock) + if (!dev->param.isYaffs2 && + !dev->param.writeChunkWithTagsToNAND && + !dev->param.readChunkWithTagsFromNAND && + dev->param.writeChunkToNAND && + dev->param.readChunkFromNAND && + !dev->param.markNANDBlockBad && + !dev->param.queryNANDBlock) return 1; - return 0; /* bad */ + return 0; /* bad */ } @@ -7422,35 +7781,35 @@ int yaffs_GutsInitialise(yaffs_Device *dev) return YAFFS_FAIL; } - dev->internalStartBlock = dev->startBlock; - dev->internalEndBlock = dev->endBlock; + dev->internalStartBlock = dev->param.startBlock; + dev->internalEndBlock = dev->param.endBlock; dev->blockOffset = 0; dev->chunkOffset = 0; dev->nFreeChunks = 0; - dev->gcBlock = -1; + dev->gcBlock = 0; - if (dev->startBlock == 0) { - dev->internalStartBlock = dev->startBlock + 1; - dev->internalEndBlock = dev->endBlock + 1; + if (dev->param.startBlock == 0) { + dev->internalStartBlock = dev->param.startBlock + 1; + dev->internalEndBlock = dev->param.endBlock + 1; dev->blockOffset = 1; - dev->chunkOffset = dev->nChunksPerBlock; + dev->chunkOffset = dev->param.nChunksPerBlock; } /* Check geometry parameters. */ - if ((!dev->inbandTags && dev->isYaffs2 && dev->totalBytesPerChunk < 1024) || - (!dev->isYaffs2 && dev->totalBytesPerChunk < 512) || - (dev->inbandTags && !dev->isYaffs2) || - dev->nChunksPerBlock < 2 || - dev->nReservedBlocks < 2 || + if ((!dev->param.inbandTags && dev->param.isYaffs2 && dev->param.totalBytesPerChunk < 1024) || + (!dev->param.isYaffs2 && dev->param.totalBytesPerChunk < 512) || + (dev->param.inbandTags && !dev->param.isYaffs2) || + dev->param.nChunksPerBlock < 2 || + dev->param.nReservedBlocks < 2 || dev->internalStartBlock <= 0 || dev->internalEndBlock <= 0 || - dev->internalEndBlock <= (dev->internalStartBlock + dev->nReservedBlocks + 2)) { /* otherwise it is too small */ + dev->internalEndBlock <= (dev->internalStartBlock + dev->param.nReservedBlocks + 2)) { /* otherwise it is too small */ T(YAFFS_TRACE_ALWAYS, (TSTR ("yaffs: NAND geometry problems: chunk size %d, type is yaffs%s, inbandTags %d " - TENDSTR), dev->totalBytesPerChunk, dev->isYaffs2 ? "2" : "", dev->inbandTags)); + TENDSTR), dev->param.totalBytesPerChunk, dev->param.isYaffs2 ? "2" : "", dev->param.inbandTags)); return YAFFS_FAIL; } @@ -7461,10 +7820,10 @@ int yaffs_GutsInitialise(yaffs_Device *dev) } /* Sort out space for inband tags, if required */ - if (dev->inbandTags) - dev->nDataBytesPerChunk = dev->totalBytesPerChunk - sizeof(yaffs_PackedTags2TagsPart); + if (dev->param.inbandTags) + dev->nDataBytesPerChunk = dev->param.totalBytesPerChunk - sizeof(yaffs_PackedTags2TagsPart); else - dev->nDataBytesPerChunk = dev->totalBytesPerChunk; + dev->nDataBytesPerChunk = dev->param.totalBytesPerChunk; /* Got the right mix of functions? */ if (!yaffs_CheckDevFunctions(dev)) { @@ -7511,12 +7870,12 @@ int yaffs_GutsInitialise(yaffs_Device *dev) * We need to find the next power of 2 > than internalEndBlock */ - x = dev->nChunksPerBlock * (dev->internalEndBlock + 1); + x = dev->param.nChunksPerBlock * (dev->internalEndBlock + 1); bits = ShiftsGE(x); /* Set up tnode width if wide tnodes are enabled. */ - if (!dev->wideTnodesDisabled) { + if (!dev->param.wideTnodesDisabled) { /* bits must be even so that we end up with 32-bit words */ if (bits & 1) bits++; @@ -7543,7 +7902,7 @@ int yaffs_GutsInitialise(yaffs_Device *dev) dev->chunkGroupSize = 1 << dev->chunkGroupBits; - if (dev->nChunksPerBlock < dev->chunkGroupSize) { + if (dev->param.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". @@ -7557,9 +7916,11 @@ int yaffs_GutsInitialise(yaffs_Device *dev) /* OK, we've finished verifying the device, lets continue with initialisation */ /* More device initialisation */ - dev->garbageCollections = 0; - dev->passiveGarbageCollections = 0; - dev->currentDirtyChecker = 0; + dev->allGCs = 0; + dev->passiveGCs = 0; + dev->oldestDirtyGCs = 0; + dev->backgroundGCs = 0; + dev->gcBlockFinder = 0; dev->bufferedBlock = -1; dev->doingBufferedBlockRewrite = 0; dev->nDeletedFiles = 0; @@ -7571,8 +7932,11 @@ int yaffs_GutsInitialise(yaffs_Device *dev) dev->tagsEccUnfixed = 0; dev->nErasureFailures = 0; dev->nErasedBlocks = 0; - dev->isDoingGC = 0; + dev->gcDisable= 0; dev->hasPendingPrioritisedGCs = 1; /* Assume the worst for now, will get fixed on first GC */ + YINIT_LIST_HEAD(&dev->dirtyDirectories); + dev->oldestDirtySequence = 0; + dev->oldestDirtyBlock = 0; /* Initialise temporary buffers and caches. */ if (!yaffs_InitialiseTempBuffers(dev)) @@ -7583,13 +7947,13 @@ int yaffs_GutsInitialise(yaffs_Device *dev) if (!init_failed && - dev->nShortOpCaches > 0) { + dev->param.nShortOpCaches > 0) { int i; void *buf; - int srCacheBytes = dev->nShortOpCaches * sizeof(yaffs_ChunkCache); + int srCacheBytes = dev->param.nShortOpCaches * sizeof(yaffs_ChunkCache); - if (dev->nShortOpCaches > YAFFS_MAX_SHORT_OP_CACHES) - dev->nShortOpCaches = YAFFS_MAX_SHORT_OP_CACHES; + if (dev->param.nShortOpCaches > YAFFS_MAX_SHORT_OP_CACHES) + dev->param.nShortOpCaches = YAFFS_MAX_SHORT_OP_CACHES; dev->srCache = YMALLOC(srCacheBytes); @@ -7598,11 +7962,11 @@ int yaffs_GutsInitialise(yaffs_Device *dev) if (dev->srCache) memset(dev->srCache, 0, srCacheBytes); - for (i = 0; i < dev->nShortOpCaches && buf; i++) { + for (i = 0; i < dev->param.nShortOpCaches && buf; i++) { dev->srCache[i].object = NULL; dev->srCache[i].lastUse = 0; dev->srCache[i].dirty = 0; - dev->srCache[i].data = buf = YMALLOC_DMA(dev->totalBytesPerChunk); + dev->srCache[i].data = buf = YMALLOC_DMA(dev->param.totalBytesPerChunk); } if (!buf) init_failed = 1; @@ -7613,13 +7977,13 @@ int yaffs_GutsInitialise(yaffs_Device *dev) dev->cacheHits = 0; if (!init_failed) { - dev->gcCleanupList = YMALLOC(dev->nChunksPerBlock * sizeof(__u32)); + dev->gcCleanupList = YMALLOC(dev->param.nChunksPerBlock * sizeof(__u32)); if (!dev->gcCleanupList) init_failed = 1; } - if (dev->isYaffs2) - dev->useHeaderFileSize = 1; + if (dev->param.isYaffs2) + dev->param.useHeaderFileSize = 1; if (!init_failed && !yaffs_InitialiseBlocks(dev)) init_failed = 1; @@ -7633,7 +7997,7 @@ int yaffs_GutsInitialise(yaffs_Device *dev) if (!init_failed) { /* Now scan the flash. */ - if (dev->isYaffs2) { + if (dev->param.isYaffs2) { if (yaffs_CheckpointRestore(dev)) { yaffs_CheckObjectDetailsLoaded(dev->rootDir); T(YAFFS_TRACE_ALWAYS, @@ -7655,7 +8019,6 @@ int yaffs_GutsInitialise(yaffs_Device *dev) dev->nDeletedFiles = 0; dev->nUnlinkedFiles = 0; dev->nBackgroundDeletions = 0; - dev->oldestDirtySequence = 0; if (!init_failed && !yaffs_InitialiseBlocks(dev)) init_failed = 1; @@ -7674,7 +8037,7 @@ int yaffs_GutsInitialise(yaffs_Device *dev) yaffs_StripDeletedObjects(dev); yaffs_FixHangingObjects(dev); - if(dev->emptyLostAndFound) + if(dev->param.emptyLostAndFound) yaffs_EmptyLostAndFound(dev); } @@ -7717,10 +8080,10 @@ void yaffs_Deinitialise(yaffs_Device *dev) yaffs_DeinitialiseBlocks(dev); yaffs_DeinitialiseTnodes(dev); yaffs_DeinitialiseObjects(dev); - if (dev->nShortOpCaches > 0 && + if (dev->param.nShortOpCaches > 0 && dev->srCache) { - for (i = 0; i < dev->nShortOpCaches; i++) { + for (i = 0; i < dev->param.nShortOpCaches; i++) { if (dev->srCache[i].data) YFREE(dev->srCache[i].data); dev->srCache[i].data = NULL; @@ -7737,34 +8100,33 @@ void yaffs_Deinitialise(yaffs_Device *dev) dev->isMounted = 0; - if (dev->deinitialiseNAND) - dev->deinitialiseNAND(dev); + if (dev->param.deinitialiseNAND) + dev->param.deinitialiseNAND(dev); } } static int yaffs_CountFreeChunks(yaffs_Device *dev) { - int nFree; + int nFree=0; int b; yaffs_BlockInfo *blk; - for (nFree = 0, b = dev->internalStartBlock; b <= dev->internalEndBlock; - b++) { - blk = yaffs_GetBlockInfo(dev, b); - + blk = dev->blockInfo; + for (b = dev->internalStartBlock; b <= dev->internalEndBlock; b++) { switch (blk->blockState) { case YAFFS_BLOCK_STATE_EMPTY: case YAFFS_BLOCK_STATE_ALLOCATING: case YAFFS_BLOCK_STATE_COLLECTING: case YAFFS_BLOCK_STATE_FULL: nFree += - (dev->nChunksPerBlock - blk->pagesInUse + + (dev->param.nChunksPerBlock - blk->pagesInUse + blk->softDeletions); break; default: break; } + blk++; } return nFree; @@ -7789,21 +8151,21 @@ int yaffs_GetNumberOfFreeChunks(yaffs_Device *dev) /* Now count the number of dirty chunks in the cache and subtract those */ - for (nDirtyCacheChunks = 0, i = 0; i < dev->nShortOpCaches; i++) { + for (nDirtyCacheChunks = 0, i = 0; i < dev->param.nShortOpCaches; i++) { if (dev->srCache[i].dirty) nDirtyCacheChunks++; } nFree -= nDirtyCacheChunks; - nFree -= ((dev->nReservedBlocks + 1) * dev->nChunksPerBlock); + nFree -= ((dev->param.nReservedBlocks + 1) * dev->param.nChunksPerBlock); /* Now we figure out how much to reserve for the checkpoint and report that... */ blocksForCheckpoint = yaffs_CalcCheckpointBlocksRequired(dev) - dev->blocksInCheckpoint; if (blocksForCheckpoint < 0) blocksForCheckpoint = 0; - nFree -= (blocksForCheckpoint * dev->nChunksPerBlock); + nFree -= (blocksForCheckpoint * dev->param.nChunksPerBlock); if (nFree < 0) nFree = 0;