/*
- * YAFFS: Yet another FFS. A NAND-flash specific file system.
+ * YAFFS: Yet another FFS. A NAND-flash specific file system.
*
* Copyright (C) 2002 Aleph One Ltd.
* for Toby Churchill Ltd and Brightstar Engineering
*/
const char *yaffs_guts_c_version =
- "$Id: yaffs_guts.c,v 1.32 2006-05-08 10:13:34 charles Exp $";
+ "$Id: yaffs_guts.c,v 1.37 2006-09-21 08:13:59 charles Exp $";
#include "yportenv.h"
#include "yaffs_tagsvalidity.h"
#include "yaffs_tagscompat.h"
+#ifndef CONFIG_YAFFS_OWN_SORT
+#include "yaffs_qsort.h"
+#endif
#include "yaffs_nand.h"
#include "yaffs_checkptrw.h"
/* Robustification (if it ever comes about...) */
static void yaffs_RetireBlock(yaffs_Device * dev, int blockInNAND);
-static void yaffs_HandleWriteChunkError(yaffs_Device * dev, int chunkInNAND);
+static void yaffs_HandleWriteChunkError(yaffs_Device * dev, int chunkInNAND, int erasedOk);
static void yaffs_HandleWriteChunkOk(yaffs_Device * dev, int chunkInNAND,
const __u8 * data,
const yaffs_ExtendedTags * tags);
/* Other local prototypes */
static int yaffs_UnlinkObject( yaffs_Object *obj);
+static int yaffs_ObjectHasCachedWriteData(yaffs_Object *obj);
static void yaffs_HardlinkFixup(yaffs_Device *dev, yaffs_Object *hardList);
loff_t yaffs_GetFileSize(yaffs_Object * obj);
-static int yaffs_AllocateChunk(yaffs_Device * dev, int useReserve);
+static int yaffs_AllocateChunk(yaffs_Device * dev, int useReserve, yaffs_BlockInfo **blockUsedPtr);
static void yaffs_VerifyFreeChunks(yaffs_Device * dev);
}
+/*
+ * Determine if we have a managed buffer.
+ */
+int yaffs_IsManagedTempBuffer(yaffs_Device * dev, const __u8 * buffer)
+{
+ int i;
+ for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) {
+ if (dev->tempBuffer[i].buffer == buffer)
+ return 1;
+
+ }
+
+ for (i = 0; i < dev->nShortOpCaches; i++) {
+ if( dev->srCache[i].data == buffer )
+ return 1;
+
+ }
+
+ if (buffer == dev->checkpointBuffer)
+ return 1;
+
+ T(YAFFS_TRACE_ALWAYS,
+ (TSTR("yaffs: unmaged buffer detected.\n" TENDSTR)));
+ return 0;
+}
+
/*
* Chunk bitmap manipulations
*/
yaffs_ExtendedTags tags;
yaffs_ReadChunkWithTagsFromNAND(dev, chunkInNAND, data, &tags);
+
+ if(tags.eccResult > YAFFS_ECC_RESULT_NO_ERROR)
+ retval = YAFFS_FAIL;
+
if (!yaffs_CheckFF(data, dev->nBytesPerChunk) || tags.chunkUsed) {
T(YAFFS_TRACE_NANDACCESS,
{
int chunk;
- int writeOk = 1;
+ int writeOk = 0;
+ int erasedOk = 1;
int attempts = 0;
+ yaffs_BlockInfo *bi;
yaffs_InvalidateCheckpoint(dev);
do {
- chunk = yaffs_AllocateChunk(dev, useReserve);
+ chunk = yaffs_AllocateChunk(dev, useReserve,&bi);
if (chunk >= 0) {
-
- /* First check this chunk is erased... */
-#ifndef CONFIG_YAFFS_DISABLE_CHUNK_ERASED_CHECK
- writeOk = yaffs_CheckChunkErased(dev, chunk);
+ /* First check this chunk is erased, if it needs checking.
+ * The checking policy (unless forced always on) is as follows:
+ * Check the first page we try to write in a block.
+ * - If the check passes then we don't need to check any more.
+ * - If the check fails, we check again...
+ * If the block has been erased, we don't need to check.
+ *
+ * However, if the block has been prioritised for gc, then
+ * we think there might be something odd about this block
+ * and should continue doing erased checks.
+ *
+ * Rationale:
+ * We should only ever see chunks that have not been erased
+ * if there was a partially written chunk due to power loss
+ * This checking policy should catch that case with very
+ * few checks and thus save a lot of checks that are most likely not
+ * needed.
+ */
+
+#ifdef CONFIG_YAFFS_ALWAYS_CHECK_CHUNK_ERASED
+ bi->skipErasedCheck = 1;
#endif
- if (!writeOk) {
+ if(!bi->skipErasedCheck){
+ erasedOk = yaffs_CheckChunkErased(dev, chunk);
+ if(erasedOk && !bi->gcPrioritise)
+ bi->skipErasedCheck = 1;
+ }
+
+ if (!erasedOk) {
T(YAFFS_TRACE_ERROR,
(TSTR
("**>> yaffs chunk %d was not erased"
yaffs_WriteChunkWithTagsToNAND(dev, chunk,
data, tags);
}
+
attempts++;
if (writeOk) {
* NB We do this at the end to prevent duplicates in the case of a write error.
* Todo
*/
- yaffs_HandleWriteChunkOk(dev, chunk, data,
- tags);
+ yaffs_HandleWriteChunkOk(dev, chunk, data, tags);
+
} else {
- yaffs_HandleWriteChunkError(dev, chunk);
+ /* The erased check or write failed */
+ yaffs_HandleWriteChunkError(dev, chunk, erasedOk);
}
}
{
}
-static void yaffs_HandleWriteChunkError(yaffs_Device * dev, int chunkInNAND)
+static void yaffs_HandleWriteChunkError(yaffs_Device * dev, int chunkInNAND, int erasedOk)
{
+
int blockInNAND = chunkInNAND / dev->nChunksPerBlock;
+ yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, blockInNAND);
+ bi->gcPrioritise = 1;
+
+ if(erasedOk) {
+ /* Was an actual write failure, so mark the block for retirement */
- /* Mark the block for retirement */
- yaffs_GetBlockInfo(dev, blockInNAND)->needsRetiring = 1;
+ bi->needsRetiring = 1;
+ }
+
/* Delete the chunk */
yaffs_DeleteChunk(dev, chunkInNAND, 1, __LINE__);
}
#endif
obj = yaffs_FindObjectByName(oldDir, oldName);
+ /* Check new name to long. */
+ if (obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK &&
+ yaffs_strlen(newName) > YAFFS_MAX_ALIAS_LENGTH)
+ /* ENAMETOOLONG */
+ return YAFFS_FAIL;
+ else if (obj->variantType != YAFFS_OBJECT_TYPE_SYMLINK &&
+ yaffs_strlen(newName) > YAFFS_MAX_NAME_LENGTH)
+ /* ENAMETOOLONG */
+ return YAFFS_FAIL;
if (obj && obj->renameAllowed) {
int iterations;
int dirtiest = -1;
int pagesInUse;
+ int prioritised;
yaffs_BlockInfo *bi;
static int nonAggressiveSkip = 0;
}
}
- for (i = 0; i <= iterations && pagesInUse > 0; i++) {
+ for (i = 0, prioritised = 0; i <= iterations && pagesInUse > 0 && !prioritised; i++) {
b++;
if (b < dev->internalStartBlock || b > dev->internalEndBlock) {
b = dev->internalStartBlock;
bi = yaffs_GetBlockInfo(dev, b);
+#if 0
+ if (bi->blockState == YAFFS_BLOCK_STATE_CHECKPOINT) {
+ dirtiest = b;
+ pagesInUse = 0;
+ }
+ else
+#endif
+
if (bi->blockState == YAFFS_BLOCK_STATE_FULL &&
- (bi->pagesInUse - bi->softDeletions) < pagesInUse &&
- yaffs_BlockNotDisqualifiedFromGC(dev, bi)) {
+ (bi->gcPrioritise || (bi->pagesInUse - bi->softDeletions)) < pagesInUse &&
+ yaffs_BlockNotDisqualifiedFromGC(dev, bi)) {
dirtiest = b;
pagesInUse = (bi->pagesInUse - bi->softDeletions);
+ if(bi->gcPrioritise)
+ prioritised = 1; /* Trick it into selecting this one */
}
}
if (dirtiest > 0) {
T(YAFFS_TRACE_GC,
- (TSTR("GC Selected block %d with %d free" TENDSTR), dirtiest,
- dev->nChunksPerBlock - pagesInUse));
+ (TSTR("GC Selected block %d with %d free, prioritised:%d" TENDSTR), dirtiest,
+ dev->nChunksPerBlock - pagesInUse,prioritised));
}
dev->oldestDirtySequence = 0;
bi->pagesInUse = 0;
bi->softDeletions = 0;
bi->hasShrinkHeader = 0;
+ bi->skipErasedCheck = 1; /* This is clean, so no need to check */
+ bi->gcPrioritise = 0;
yaffs_ClearChunkBits(dev, blockNo);
T(YAFFS_TRACE_ERASE,
}
-
+// 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)
{
- int reservedChunks = (dev->nReservedBlocks * dev->nChunksPerBlock);
+ int reservedChunks;
+ int reservedBlocks = dev->nReservedBlocks;
+ int checkpointBlocks;
+
+ checkpointBlocks = dev->nCheckpointReservedBlocks - dev->blocksInCheckpoint;
+ if(checkpointBlocks < 0)
+ checkpointBlocks = 0;
+
+ reservedChunks = ((reservedBlocks + checkpointBlocks) * dev->nChunksPerBlock);
+
return (dev->nFreeChunks > reservedChunks);
}
-static int yaffs_AllocateChunk(yaffs_Device * dev, int useReserve)
+static int yaffs_AllocateChunk(yaffs_Device * dev, int useReserve, yaffs_BlockInfo **blockUsedPtr)
{
int retVal;
yaffs_BlockInfo *bi;
dev->allocationBlock = -1;
}
+ if(blockUsedPtr)
+ *blockUsedPtr = bi;
+
return retVal;
}
int retVal = YAFFS_OK;
int cleanups = 0;
int i;
+ int isCheckpointBlock;
int chunksBefore = yaffs_GetErasedChunks(dev);
int chunksAfter;
yaffs_Object *object;
+ isCheckpointBlock = (bi->blockState == YAFFS_BLOCK_STATE_CHECKPOINT);
+
bi->blockState = YAFFS_BLOCK_STATE_COLLECTING;
T(YAFFS_TRACE_TRACING,
dev->isDoingGC = 1;
- if (!yaffs_StillSomeChunkBits(dev, block)) {
+ if (isCheckpointBlock ||
+ !yaffs_StillSomeChunkBits(dev, block)) {
T(YAFFS_TRACE_TRACING,
(TSTR
("Collecting block %d that has no chunks in use" TENDSTR),
int aggressive;
int gcOk = YAFFS_OK;
int maxTries = 0;
+
+ int checkpointBlockAdjust;
if (dev->isDoingGC) {
/* Bail out so we don't get recursive gc */
do {
maxTries++;
- if (dev->nErasedBlocks < dev->nReservedBlocks) {
+
+ checkpointBlockAdjust = (dev->nCheckpointReservedBlocks - dev->blocksInCheckpoint);
+ if(checkpointBlockAdjust < 0)
+ checkpointBlockAdjust = 0;
+
+ if (dev->nErasedBlocks < (dev->nReservedBlocks + checkpointBlockAdjust)) {
/* We need a block soon...*/
aggressive = 1;
} else {
__LINE__);
}
- in->dirty = 0;
+ if(!yaffs_ObjectHasCachedWriteData(in))
+ in->dirty = 0;
/* If this was a shrink, then mark the block that the chunk lives on */
if (isShrink) {
* need a very intelligent search.
*/
+static int yaffs_ObjectHasCachedWriteData(yaffs_Object *obj)
+{
+ yaffs_Device *dev = obj->myDev;
+ int i;
+ yaffs_ChunkCache *cache;
+ int nCaches = obj->myDev->nShortOpCaches;
+
+ if(nCaches > 0){
+ for(i = 0; i < nCaches; i++){
+ if (dev->srCache[i].object == obj &&
+ dev->srCache[i].dirty)
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
+
static void yaffs_FlushFilesChunkCache(yaffs_Object * obj)
{
yaffs_Device *dev = obj->myDev;
{
int i;
yaffs_Device *dev = in->myDev;
+ int ok = 1;
+ int nTnodeBytes = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
if (tn) {
if (level > 0) {
- for (i = 0; i < YAFFS_NTNODES_INTERNAL; i++){
+ for (i = 0; i < YAFFS_NTNODES_INTERNAL && ok; i++){
if (tn->internal[i]) {
- yaffs_CheckpointTnodeWorker(in,
+ ok = yaffs_CheckpointTnodeWorker(in,
tn->internal[i],
level - 1,
(chunkOffset<<YAFFS_TNODES_INTERNAL_BITS) + i);
} else if (level == 0) {
__u32 baseOffset = chunkOffset << YAFFS_TNODES_LEVEL0_BITS;
/* printf("write tnode at %d\n",baseOffset); */
- yaffs_CheckpointWrite(dev,&baseOffset,sizeof(baseOffset));
- yaffs_CheckpointWrite(dev,tn,(dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8);
+ ok = (yaffs_CheckpointWrite(dev,&baseOffset,sizeof(baseOffset)) == sizeof(baseOffset));
+ if(ok)
+ ok = (yaffs_CheckpointWrite(dev,tn,nTnodeBytes) == nTnodeBytes);
}
}
- return 1;
+ return ok;
}
static int yaffs_WriteCheckpointTnodes(yaffs_Object *obj)
{
__u32 endMarker = ~0;
- int ok;
+ int ok = 1;
if(obj->variantType == YAFFS_OBJECT_TYPE_FILE){
ok = yaffs_CheckpointTnodeWorker(obj,
if(ok && cp.objectId == ~0)
done = 1;
- else {
- /* printf("Read object %d type %d\n",cp.objectId,cp.variantType); */
+ else if(ok){
+ T(YAFFS_TRACE_CHECKPOINT,(TSTR("Read object %d parent %d type %d" TENDSTR),
+ cp.objectId,cp.parentId,cp.variantType));
obj = yaffs_FindOrCreateObjectByNumber(dev,cp.objectId, cp.variantType);
if(obj) {
yaffs_CheckpointObjectToObject(obj,&cp);
if(obj->variantType == YAFFS_OBJECT_TYPE_FILE) {
- yaffs_ReadCheckpointTnodes(obj);
+ ok = yaffs_ReadCheckpointTnodes(obj);
} else if(obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) {
obj->hardLinks.next =
(struct list_head *)
if(ok)
ok = yaffs_WriteCheckpointValidityMarker(dev,0);
- yaffs_CheckpointClose(dev);
-
+ if(!yaffs_CheckpointClose(dev))
+ ok = 0;
+
if(ok)
dev->isCheckpointed = 1;
else
if(ok)
ok = yaffs_ReadCheckpointValidityMarker(dev,0);
-
+
+
+ if(!yaffs_CheckpointClose(dev))
+ ok = 0;
+
if(ok)
dev->isCheckpointed = 1;
else
dev->isCheckpointed = 0;
- yaffs_CheckpointClose(dev);
-
return ok ? 1 : 0;
}
static void yaffs_InvalidateCheckpoint(yaffs_Device *dev)
{
- if(dev->isCheckpointed){
+ if(dev->isCheckpointed ||
+ dev->blocksInCheckpoint > 0){
dev->isCheckpointed = 0;
yaffs_CheckpointInvalidateStream(dev);
+ if(dev->superBlock && dev->markSuperBlockDirty)
+ dev->markSuperBlockDirty(dev->superBlock);
}
}
int yaffs_CheckpointSave(yaffs_Device *dev)
{
+ T(YAFFS_TRACE_CHECKPOINT,(TSTR("save entry: isCheckpointed %d"TENDSTR),dev->isCheckpointed));
+
if(!dev->isCheckpointed)
yaffs_WriteCheckpointData(dev);
+ T(YAFFS_TRACE_CHECKPOINT,(TSTR("save exit: isCheckpointed %d"TENDSTR),dev->isCheckpointed));
+
return dev->isCheckpointed;
}
int yaffs_CheckpointRestore(yaffs_Device *dev)
{
+ int retval;
+ T(YAFFS_TRACE_CHECKPOINT,(TSTR("restore entry: isCheckpointed %d"TENDSTR),dev->isCheckpointed));
- return yaffs_ReadCheckpointData(dev);
+ retval = yaffs_ReadCheckpointData(dev);
+
+ T(YAFFS_TRACE_CHECKPOINT,(TSTR("restore exit: isCheckpointed %d"TENDSTR),dev->isCheckpointed));
+
+ return retval;
}
/*--------------------- File read/write ------------------------
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->
data);
}
+ else if(cache &&
+ !cache->dirty &&
+ !yaffs_CheckSpaceForAllocation(in->myDev)){
+ /* Drop the cache if it was a read cache item and
+ * no space check has been made for it.
+ */
+ cache = NULL;
+ }
if (cache) {
yaffs_UseChunkCache(dev, cache, 1);
+static int ybicmp(const void *a, const void *b){
+ register int aseq = ((yaffs_BlockIndex *)a)->seq;
+ register int bseq = ((yaffs_BlockIndex *)b)->seq;
+ register int ablock = ((yaffs_BlockIndex *)a)->block;
+ register int bblock = ((yaffs_BlockIndex *)b)->block;
+ if( aseq == bseq )
+ return ablock - bblock;
+ else
+ return aseq - bseq;
+
+}
+
static int yaffs_Scan(yaffs_Device * dev)
{
yaffs_ExtendedTags tags;
yaffs_BlockIndex *blockIndex = NULL;
+ if (dev->isYaffs2) {
+ T(YAFFS_TRACE_SCAN,
+ (TSTR("yaffs_Scan is not for YAFFS2!" TENDSTR)));
+ return YAFFS_FAIL;
+ }
+
+ //TODO Throw all the yaffs2 stuuf out of yaffs_Scan since it is only for yaffs1 format.
+
T(YAFFS_TRACE_SCAN,
(TSTR("yaffs_Scan starts intstartblk %d intendblk %d..." TENDSTR),
dev->internalStartBlock, dev->internalEndBlock));
int fileSize;
int isShrink;
+ int foundChunksInBlock;
int equivalentObjectId;
yaffs_BlockIndex *blockIndex = NULL;
+ int altBlockIndex = 0;
if (!dev->isYaffs2) {
T(YAFFS_TRACE_SCAN,
("yaffs_ScanBackwards starts intstartblk %d intendblk %d..."
TENDSTR), dev->internalStartBlock, dev->internalEndBlock));
- chunkData = yaffs_GetTempBuffer(dev, __LINE__);
dev->sequenceNumber = YAFFS_LOWEST_SEQUENCE_NUMBER;
blockIndex = YMALLOC(nBlocks * sizeof(yaffs_BlockIndex));
+
+ if(!blockIndex) {
+ blockIndex = YMALLOC_ALT(nBlocks * sizeof(yaffs_BlockIndex));
+ altBlockIndex = 1;
+ }
+
+ if(!blockIndex) {
+ T(YAFFS_TRACE_SCAN,
+ (TSTR("yaffs_Scan() could not allocate block index!" TENDSTR)));
+ return YAFFS_FAIL;
+ }
+
+ chunkData = yaffs_GetTempBuffer(dev, __LINE__);
/* Scan all the blocks to determine their state */
for (blk = dev->internalStartBlock; blk <= dev->internalEndBlock; blk++) {
bi->blockState = state;
bi->sequenceNumber = sequenceNumber;
+ if(bi->sequenceNumber == YAFFS_SEQUENCE_CHECKPOINT_DATA)
+ bi->blockState = state = YAFFS_BLOCK_STATE_CHECKPOINT;
+
T(YAFFS_TRACE_SCAN_DEBUG,
(TSTR("Block scanning block %d state %d seq %d" TENDSTR), blk,
state, sequenceNumber));
- if (state == YAFFS_BLOCK_STATE_DEAD) {
+
+ if(state == YAFFS_BLOCK_STATE_CHECKPOINT){
+ /* todo .. fix free space ? */
+
+ } else if (state == YAFFS_BLOCK_STATE_DEAD) {
T(YAFFS_TRACE_BAD_BLOCKS,
(TSTR("block %d is bad" TENDSTR), blk));
} else if (state == YAFFS_BLOCK_STATE_EMPTY) {
}
}
- /*
- * Sort the blocks
- * Dungy old bubble sort for now...
- */
+ T(YAFFS_TRACE_SCAN,
+ (TSTR("%d blocks to be sorted..." TENDSTR), nBlocksToScan));
+
+
+
+ YYIELD();
+
+ /* Sort the blocks */
+#ifndef CONFIG_YAFFS_USE_OWN_SORT
+ {
+ /* Use qsort now. */
+ qsort(blockIndex, nBlocksToScan, sizeof(yaffs_BlockIndex), ybicmp);
+ }
+#else
{
+ /* Dungy old bubble sort... */
+
yaffs_BlockIndex temp;
int i;
int j;
blockIndex[i] = temp;
}
}
+#endif
+
+ YYIELD();
+
+ T(YAFFS_TRACE_SCAN, (TSTR("...done" TENDSTR)));
/* Now scan the blocks looking at the data. */
startIterator = 0;
/* For each block.... backwards */
for (blockIterator = endIterator; blockIterator >= startIterator;
blockIterator--) {
+ /* Cooperative multitasking! This loop can run for so
+ long that watchdog timers expire. */
+ YYIELD();
/* get the block to scan in the correct order */
blk = blockIndex[blockIterator].block;
deleted = 0;
/* For each chunk in each block that needs scanning.... */
+ foundChunksInBlock = 0;
for (c = dev->nChunksPerBlock - 1; c >= 0 &&
(state == YAFFS_BLOCK_STATE_NEEDS_SCANNING ||
state == YAFFS_BLOCK_STATE_ALLOCATING); c--) {
/* Let's have a good look at this chunk... */
if (!tags.chunkUsed) {
- // An unassigned chunk in the block
- // This means that either the block is empty or
- // this is the one being allocated from
+ /* An unassigned chunk in the block.
+ * If there are used chunks after this one, then
+ * it is a chunk that was skipped due to failing the erased
+ * check. Just skip it so that it can be deleted.
+ * But, more typically, We get here when this is an unallocated
+ * chunk and his means that either the block is empty or
+ * this is the one being allocated from
+ */
- if (c == 0) {
+ if(foundChunksInBlock)
+ {
+ /* This is a chunk that was skipped due to failing the erased check */
+
+ } else if (c == 0) {
/* We're looking at the first chunk in the block so the block is unused */
state = YAFFS_BLOCK_STATE_EMPTY;
dev->nErasedBlocks++;
} else if (tags.chunkId > 0) {
/* chunkId > 0 so it is a data chunk... */
unsigned int endpos;
-
__u32 chunkBase =
(tags.chunkId - 1) * dev->nBytesPerChunk;
+
+ foundChunksInBlock = 1;
+
yaffs_SetChunkBit(dev, blk, c);
bi->pagesInUse++;
/* chunkId == 0, so it is an ObjectHeader.
* Thus, we read in the object header and make the object
*/
+ foundChunksInBlock = 1;
+
yaffs_SetChunkBit(dev, blk, c);
bi->pagesInUse++;
}
- if (blockIndex) {
+ if (altBlockIndex)
+ YFREE_ALT(blockIndex);
+ else
YFREE(blockIndex);
- }
+
/* Ok, we've done all the scanning.
* Fix up the hard link chains.
* We should now have scanned all the objects, now it's time to add these
for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) {
dev->tempBuffer[i].line = 0; /* not in use */
dev->tempBuffer[i].buffer =
- YMALLOC(dev->nBytesPerChunk);
+ YMALLOC_DMA(dev->nBytesPerChunk);
}
}
dev->srCache[i].object = NULL;
dev->srCache[i].lastUse = 0;
dev->srCache[i].dirty = 0;
- dev->srCache[i].data = YMALLOC(dev->nBytesPerChunk);
+ dev->srCache[i].data = YMALLOC_DMA(dev->nBytesPerChunk);
}
dev->srLastUse = 0;
}
int nFree;
int nDirtyCacheChunks;
+ int blocksForCheckpoint;
#if 1
nFree = dev->nFreeChunks;
nFree -= nDirtyCacheChunks;
nFree -= ((dev->nReservedBlocks + 1) * dev->nChunksPerBlock);
+
+ /* Now we figure out how much to reserve for the checkpoint and report that... */
+ blocksForCheckpoint = dev->nCheckpointReservedBlocks - dev->blocksInCheckpoint;
+ if(blocksForCheckpoint < 0)
+ blocksForCheckpoint = 0;
+
+ nFree -= (blocksForCheckpoint * dev->nChunksPerBlock);
if (nFree < 0)
nFree = 0;
projects / yaffs2.git / blobdiff