Add dummy uses for unused variables to clear compilation warnings
[yaffs2.git] / yaffs_guts.c
index c5d20b17a9e72ae2100d30c707bd423d7e19a168..fd3d636d8f48e6f432efe2ffb43a8f92234286fa 100644 (file)
@@ -12,7 +12,7 @@
  */
 
 const char *yaffs_guts_c_version =
-    "$Id: yaffs_guts.c,v 1.109 2010-02-24 21:06:39 charles Exp $";
+    "$Id: yaffs_guts.c,v 1.113 2010-03-05 02:26:27 charles Exp $";
 
 #include "yportenv.h"
 #include "yaffs_trace.h"
@@ -404,16 +404,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));
 }
 
@@ -682,12 +685,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.
@@ -1100,11 +1097,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)
@@ -1452,6 +1456,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;
@@ -2135,33 +2141,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;
                }
 
        }
@@ -2705,7 +2699,72 @@ static int yaffs_BlockNotDisqualifiedFromGC(yaffs_Device *dev,
        return (bi->sequenceNumber <= dev->oldestDirtySequence);
 }
 
-/* FindDiretiestBlock is used to select the dirtiest block (or close enough)
+/*
+ * yaffs_FindRefreshBlock()
+ * periodically finds the oldest full block by sequence number for refreshing.
+ * Only for yaffs2.
+ */
+static __u32 yaffs_FindRefreshBlock(yaffs_Device *dev)
+{
+       __u32 b ;
+
+       __u32 oldest = 0;
+       __u32 oldestSequence = 0;
+
+       yaffs_BlockInfo *bi;
+
+       /*
+        * If refresh period < 10 then refreshing is disabled.
+        */
+       if(dev->param.refreshPeriod < 10 ||
+               !dev->param.isYaffs2)
+               return oldest;
+
+        /*
+         * Fix broken values.
+         */
+        if(dev->refreshSkip > dev->param.refreshPeriod)
+                dev->refreshSkip = dev->param.refreshPeriod;
+
+       if(dev->refreshSkip > 0){
+               dev->refreshSkip--;
+               return oldest;
+       }
+
+       /*
+        * 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++;
+
+       for (b = dev->internalStartBlock; b <=dev->internalEndBlock; b++){
+
+               bi = yaffs_GetBlockInfo(dev, b);
+               
+
+               if (bi->blockState == YAFFS_BLOCK_STATE_FULL){
+
+                       if(oldest < 1 ||
+                                bi->sequenceNumber < oldestSequence){
+                                oldest = b;
+                                oldestSequence = bi->sequenceNumber;
+                        }
+               }
+       }
+
+       if (oldest > 0) {
+               T(YAFFS_TRACE_GC,
+                 (TSTR("GC refresh count %d selected block %d with sequenceNumber %d" TENDSTR),
+                  dev->refreshCount, oldest, oldestSequence));
+       }
+
+       return oldest;
+}
+
+/*
+ * FindDiretiestBlock is used to select the dirtiest block (or close enough)
  * for garbage collection.
  */
 
@@ -2851,6 +2910,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;
@@ -3226,13 +3286,16 @@ static int yaffs_GarbageCollectBlock(yaffs_Device *dev, int block,
                                                tags.extraIsShrinkHeader = 0;
                                                oh->shadowsObject = 0;
                                                oh->inbandShadowsObject = 0;
+                                               if(object->variantType == YAFFS_OBJECT_TYPE_FILE)
+                                                       oh->fileSize = object->variant.fileVariant.fileSize;
                                                tags.extraShadows = 0;
 
                                                yaffs_VerifyObjectHeader(object, oh, &tags, 1);
-                                       }
-
-                                       newChunk =
-                                           yaffs_WriteNewChunkWithTagsToNAND(dev, buffer, &tags, 1);
+                                               newChunk =
+                                                   yaffs_WriteNewChunkWithTagsToNAND(dev,(__u8 *) oh, &tags, 1);
+                                       } else
+                                               newChunk =
+                                                   yaffs_WriteNewChunkWithTagsToNAND(dev, buffer, &tags, 1);
 
                                        if (newChunk < 0) {
                                                retVal = YAFFS_FAIL;
@@ -3289,16 +3352,17 @@ 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) {
+               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 = -1;
                dev->gcChunk = 0;
        }
@@ -3342,15 +3406,19 @@ static int yaffs_CheckGarbageCollection(yaffs_Device *dev)
                if (checkpointBlockAdjust < 0)
                        checkpointBlockAdjust = 0;
 
-               if (dev->nErasedBlocks < (dev->param.nReservedBlocks + checkpointBlockAdjust + 2)) {
-                       /* We need a block soon...*/
+               /* If we need a block soon then do aggressive gc.*/
+               if (dev->nErasedBlocks < (dev->param.nReservedBlocks + checkpointBlockAdjust + 2))
                        aggressive = 1;
-               } else {
-                       /* We're in no hurry */
+               else
                        aggressive = 0;
-               }
 
-               if (dev->gcBlock <= 0) {
+                /* 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);
                        dev->gcChunk = 0;
                }
@@ -3750,9 +3818,9 @@ static int yaffs_WriteChunkDataToObject(yaffs_Object *in, int chunkInInode,
         * the tnode now, rather than later when it is harder to clean up.
         */
        prevChunkId = yaffs_FindChunkInFile(in, chunkInInode, &prevTags);
-       if(prevChunkId <= 0 &&
-               !yaffs_PutChunkIntoFile(in, chunkInInode, 0, 0)){
-       }
+       if(prevChunkId < 1 &&
+               !yaffs_PutChunkIntoFile(in, chunkInInode, 0, 0))
+               return 0;
 
        /* Set up new tags */
        yaffs_InitialiseTags(&newTags);
@@ -3769,13 +3837,6 @@ static int yaffs_WriteChunkDataToObject(yaffs_Object *in, int chunkInInode,
                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,
@@ -4266,7 +4327,6 @@ static void yaffs_DeviceToCheckpointDevice(yaffs_CheckpointDevice *cp,
        cp->nUnlinkedFiles = dev->nUnlinkedFiles;
        cp->nBackgroundDeletions = dev->nBackgroundDeletions;
        cp->sequenceNumber = dev->sequenceNumber;
-       cp->oldestDirtySequence = dev->oldestDirtySequence;
 
 }
 
@@ -4282,7 +4342,6 @@ static void yaffs_CheckpointDeviceToDevice(yaffs_Device *dev,
        dev->nUnlinkedFiles = cp->nUnlinkedFiles;
        dev->nBackgroundDeletions = cp->nBackgroundDeletions;
        dev->sequenceNumber = cp->sequenceNumber;
-       dev->oldestDirtySequence = cp->oldestDirtySequence;
 }
 
 
@@ -5158,7 +5217,6 @@ int yaffs_ResizeFile(yaffs_Object *in, loff_t newSize)
                in->variant.fileVariant.fileSize = newSize;
        }
 
-
        /* Write a new object header to reflect the resize.
         * show we've shrunk the file, if need be
         * Do this only if the file is not in the deleted directories
@@ -6472,35 +6530,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__);
 
                                }
@@ -6517,9 +6566,9 @@ 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;
                                }
@@ -6601,13 +6650,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;
@@ -6780,14 +6824,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:
@@ -7570,6 +7612,7 @@ int yaffs_GutsInitialise(yaffs_Device *dev)
        dev->nErasedBlocks = 0;
        dev->isDoingGC = 0;
        dev->hasPendingPrioritisedGCs = 1; /* Assume the worst for now, will get fixed on first GC */
+       dev->oldestDirtySequence = 0;
 
        /* Initialise temporary buffers and caches. */
        if (!yaffs_InitialiseTempBuffers(dev))
@@ -7652,7 +7695,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;