[kernel] nuke trailing whitespaces in the yaffs code
authorGabor Juhos <juhosg@openwrt.org>
Wed, 28 May 2008 07:31:26 +0000 (07:31 +0000)
committerGabor Juhos <juhosg@openwrt.org>
Wed, 28 May 2008 07:31:26 +0000 (07:31 +0000)
SVN-Revision: 11277

56 files changed:
target/linux/generic-2.6/files-2.6.25/fs/yaffs2/Kconfig
target/linux/generic-2.6/files-2.6.25/fs/yaffs2/devextras.h
target/linux/generic-2.6/files-2.6.25/fs/yaffs2/moduleconfig.h
target/linux/generic-2.6/files-2.6.25/fs/yaffs2/yaffs_checkptrw.c
target/linux/generic-2.6/files-2.6.25/fs/yaffs2/yaffs_checkptrw.h
target/linux/generic-2.6/files-2.6.25/fs/yaffs2/yaffs_ecc.c
target/linux/generic-2.6/files-2.6.25/fs/yaffs2/yaffs_ecc.h
target/linux/generic-2.6/files-2.6.25/fs/yaffs2/yaffs_fs.c
target/linux/generic-2.6/files-2.6.25/fs/yaffs2/yaffs_guts.c
target/linux/generic-2.6/files-2.6.25/fs/yaffs2/yaffs_guts.h
target/linux/generic-2.6/files-2.6.25/fs/yaffs2/yaffs_mtdif.c
target/linux/generic-2.6/files-2.6.25/fs/yaffs2/yaffs_mtdif.h
target/linux/generic-2.6/files-2.6.25/fs/yaffs2/yaffs_mtdif1-compat.c
target/linux/generic-2.6/files-2.6.25/fs/yaffs2/yaffs_mtdif1.c
target/linux/generic-2.6/files-2.6.25/fs/yaffs2/yaffs_mtdif2.c
target/linux/generic-2.6/files-2.6.25/fs/yaffs2/yaffs_mtdif2.h
target/linux/generic-2.6/files-2.6.25/fs/yaffs2/yaffs_nand.c
target/linux/generic-2.6/files-2.6.25/fs/yaffs2/yaffs_nand.h
target/linux/generic-2.6/files-2.6.25/fs/yaffs2/yaffs_nandemul2k.h
target/linux/generic-2.6/files-2.6.25/fs/yaffs2/yaffs_packedtags1.h
target/linux/generic-2.6/files-2.6.25/fs/yaffs2/yaffs_packedtags2.c
target/linux/generic-2.6/files-2.6.25/fs/yaffs2/yaffs_packedtags2.h
target/linux/generic-2.6/files-2.6.25/fs/yaffs2/yaffs_qsort.c
target/linux/generic-2.6/files-2.6.25/fs/yaffs2/yaffs_qsort.h
target/linux/generic-2.6/files-2.6.25/fs/yaffs2/yaffs_tagscompat.h
target/linux/generic-2.6/files-2.6.25/fs/yaffs2/yaffs_tagsvalidity.h
target/linux/generic-2.6/files-2.6.25/fs/yaffs2/yaffsinterface.h
target/linux/generic-2.6/files-2.6.25/fs/yaffs2/yportenv.h
target/linux/generic-2.6/files/fs/yaffs2/Kconfig
target/linux/generic-2.6/files/fs/yaffs2/devextras.h
target/linux/generic-2.6/files/fs/yaffs2/moduleconfig.h
target/linux/generic-2.6/files/fs/yaffs2/yaffs_checkptrw.c
target/linux/generic-2.6/files/fs/yaffs2/yaffs_checkptrw.h
target/linux/generic-2.6/files/fs/yaffs2/yaffs_ecc.c
target/linux/generic-2.6/files/fs/yaffs2/yaffs_ecc.h
target/linux/generic-2.6/files/fs/yaffs2/yaffs_fs.c
target/linux/generic-2.6/files/fs/yaffs2/yaffs_guts.c
target/linux/generic-2.6/files/fs/yaffs2/yaffs_guts.h
target/linux/generic-2.6/files/fs/yaffs2/yaffs_mtdif.c
target/linux/generic-2.6/files/fs/yaffs2/yaffs_mtdif.h
target/linux/generic-2.6/files/fs/yaffs2/yaffs_mtdif1-compat.c
target/linux/generic-2.6/files/fs/yaffs2/yaffs_mtdif1.c
target/linux/generic-2.6/files/fs/yaffs2/yaffs_mtdif2.c
target/linux/generic-2.6/files/fs/yaffs2/yaffs_mtdif2.h
target/linux/generic-2.6/files/fs/yaffs2/yaffs_nand.c
target/linux/generic-2.6/files/fs/yaffs2/yaffs_nand.h
target/linux/generic-2.6/files/fs/yaffs2/yaffs_nandemul2k.h
target/linux/generic-2.6/files/fs/yaffs2/yaffs_packedtags1.h
target/linux/generic-2.6/files/fs/yaffs2/yaffs_packedtags2.c
target/linux/generic-2.6/files/fs/yaffs2/yaffs_packedtags2.h
target/linux/generic-2.6/files/fs/yaffs2/yaffs_qsort.c
target/linux/generic-2.6/files/fs/yaffs2/yaffs_qsort.h
target/linux/generic-2.6/files/fs/yaffs2/yaffs_tagscompat.h
target/linux/generic-2.6/files/fs/yaffs2/yaffs_tagsvalidity.h
target/linux/generic-2.6/files/fs/yaffs2/yaffsinterface.h
target/linux/generic-2.6/files/fs/yaffs2/yportenv.h

index f55b3c5107bf35a9edd4caeb800007e35af75c73..7b6f836cdacc6890ee32413951910f2bf873c9ad 100644 (file)
@@ -26,7 +26,7 @@ config YAFFS_YAFFS1
        default y
        help
          Enable YAFFS1 support -- yaffs for 512 byte / page devices
-         
+
          Not needed for 2K-page devices.
 
          If unsure, say Y.
@@ -157,9 +157,9 @@ config YAFFS_ALWAYS_CHECK_CHUNK_ERASED
          Enabling this forces on the test that chunks are erased in flash
          before writing to them. This takes more time but is potentially
          a bit more secure.
+
          Suggest setting Y during development and ironing out driver
-         issues etc. Suggest setting to N if you want faster writing.  
+         issues etc. Suggest setting to N if you want faster writing.
 
          If unsure, say Y.
 
index 9635c7a73813f095c657f5bd7a08fc05448c73db..fcf2690a56a609bdde96d5be5339c8e523efdb13 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
@@ -15,7 +15,7 @@
 
 /*
  * This file is just holds extra declarations used during development.
- * Most of these are from kernel includes placed here so we can use them in 
+ * Most of these are from kernel includes placed here so we can use them in
  * applications.
  *
  */
index 8eb1ca314fcc229225e9aae7627d2f650c89fd8a..016391ca59e13bbe3d3ef895468d2cbbaadf757c 100644 (file)
@@ -1,10 +1,10 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
  *
- * Created by Martin Fouts <Martin.Fouts@palmsource.com> 
+ * Created by Martin Fouts <Martin.Fouts@palmsource.com>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License version 2.1 as
index 2f3f875f75a65e677c6ee24688a3804550746077..933a33fb8bfc6674954b891aa0a6e0e4b5f0701c 100644 (file)
@@ -22,27 +22,27 @@ static int yaffs_CheckpointSpaceOk(yaffs_Device *dev)
 {
 
        int blocksAvailable = dev->nErasedBlocks - dev->nReservedBlocks;
-       
+
        T(YAFFS_TRACE_CHECKPOINT,
                (TSTR("checkpt blocks available = %d" TENDSTR),
                blocksAvailable));
-               
-       
+
+
        return (blocksAvailable <= 0) ? 0 : 1;
 }
 
 
 static int yaffs_CheckpointErase(yaffs_Device *dev)
 {
-       
+
        int i;
-       
 
-       if(!dev->eraseBlockInNAND)      
+
+       if(!dev->eraseBlockInNAND)
                return 0;
        T(YAFFS_TRACE_CHECKPOINT,(TSTR("checking blocks %d to %d"TENDSTR),
                dev->internalStartBlock,dev->internalEndBlock));
-               
+
        for(i = dev->internalStartBlock; i <= dev->internalEndBlock; i++) {
                yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev,i);
                if(bi->blockState == YAFFS_BLOCK_STATE_CHECKPOINT){
@@ -58,9 +58,9 @@ static int yaffs_CheckpointErase(yaffs_Device *dev)
                        }
                }
        }
-       
+
        dev->blocksInCheckpoint = 0;
-       
+
        return 1;
 }
 
@@ -72,11 +72,11 @@ static void yaffs_CheckpointFindNextErasedBlock(yaffs_Device *dev)
        T(YAFFS_TRACE_CHECKPOINT,
                (TSTR("allocating checkpt block: erased %d reserved %d avail %d next %d "TENDSTR),
                dev->nErasedBlocks,dev->nReservedBlocks,blocksAvailable,dev->checkpointNextBlock));
-               
+
        if(dev->checkpointNextBlock >= 0 &&
           dev->checkpointNextBlock <= dev->internalEndBlock &&
           blocksAvailable > 0){
-       
+
                for(i = dev->checkpointNextBlock; i <= dev->internalEndBlock; i++){
                        yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev,i);
                        if(bi->blockState == YAFFS_BLOCK_STATE_EMPTY){
@@ -88,7 +88,7 @@ static void yaffs_CheckpointFindNextErasedBlock(yaffs_Device *dev)
                }
        }
        T(YAFFS_TRACE_CHECKPOINT,(TSTR("out of checkpt blocks"TENDSTR)));
-       
+
        dev->checkpointNextBlock = -1;
        dev->checkpointCurrentBlock = -1;
 }
@@ -97,19 +97,19 @@ static void yaffs_CheckpointFindNextCheckpointBlock(yaffs_Device *dev)
 {
        int  i;
        yaffs_ExtendedTags tags;
-       
+
        T(YAFFS_TRACE_CHECKPOINT,(TSTR("find next checkpt block: start:  blocks %d next %d" TENDSTR),
                dev->blocksInCheckpoint, dev->checkpointNextBlock));
-               
-       if(dev->blocksInCheckpoint < dev->checkpointMaxBlocks) 
+
+       if(dev->blocksInCheckpoint < dev->checkpointMaxBlocks)
                for(i = dev->checkpointNextBlock; i <= dev->internalEndBlock; i++){
                        int chunk = i * dev->nChunksPerBlock;
                        int realignedChunk = chunk - dev->chunkOffset;
 
                        dev->readChunkWithTagsFromNAND(dev,realignedChunk,NULL,&tags);
-                       T(YAFFS_TRACE_CHECKPOINT,(TSTR("find next checkpt block: search: block %d oid %d seq %d eccr %d" TENDSTR), 
+                       T(YAFFS_TRACE_CHECKPOINT,(TSTR("find next checkpt block: search: block %d oid %d seq %d eccr %d" TENDSTR),
                                i, tags.objectId,tags.sequenceNumber,tags.eccResult));
-                                                     
+
                        if(tags.sequenceNumber == YAFFS_SEQUENCE_CHECKPOINT_DATA){
                                /* Right kind of block */
                                dev->checkpointNextBlock = tags.objectId;
@@ -130,7 +130,7 @@ static void yaffs_CheckpointFindNextCheckpointBlock(yaffs_Device *dev)
 
 int yaffs_CheckpointOpen(yaffs_Device *dev, int forWriting)
 {
-       
+
        /* Got the functions we need? */
        if (!dev->writeChunkWithTagsToNAND ||
            !dev->readChunkWithTagsFromNAND ||
@@ -140,31 +140,31 @@ int yaffs_CheckpointOpen(yaffs_Device *dev, int forWriting)
 
        if(forWriting && !yaffs_CheckpointSpaceOk(dev))
                return 0;
-                       
+
        if(!dev->checkpointBuffer)
                dev->checkpointBuffer = YMALLOC_DMA(dev->nDataBytesPerChunk);
        if(!dev->checkpointBuffer)
                return 0;
 
-       
+
        dev->checkpointPageSequence = 0;
-       
+
        dev->checkpointOpenForWrite = forWriting;
-       
+
        dev->checkpointByteCount = 0;
        dev->checkpointSum = 0;
        dev->checkpointXor = 0;
        dev->checkpointCurrentBlock = -1;
        dev->checkpointCurrentChunk = -1;
        dev->checkpointNextBlock = dev->internalStartBlock;
-       
+
        /* Erase all the blocks in the checkpoint area */
        if(forWriting){
                memset(dev->checkpointBuffer,0,dev->nDataBytesPerChunk);
                dev->checkpointByteOffset = 0;
                return yaffs_CheckpointErase(dev);
-               
-               
+
+
        } else {
                int i;
                /* Set to a value that will kick off a read */
@@ -177,7 +177,7 @@ int yaffs_CheckpointOpen(yaffs_Device *dev, int forWriting)
                for(i = 0; i < dev->checkpointMaxBlocks; i++)
                        dev->checkpointBlockList[i] = -1;
        }
-       
+
        return 1;
 }
 
@@ -196,15 +196,15 @@ static int yaffs_CheckpointFlushBuffer(yaffs_Device *dev)
        int realignedChunk;
 
        yaffs_ExtendedTags tags;
-       
+
        if(dev->checkpointCurrentBlock < 0){
                yaffs_CheckpointFindNextErasedBlock(dev);
                dev->checkpointCurrentChunk = 0;
        }
-       
+
        if(dev->checkpointCurrentBlock < 0)
                return 0;
-       
+
        tags.chunkDeleted = 0;
        tags.objectId = dev->checkpointNextBlock; /* Hint to next place to look */
        tags.chunkId = dev->checkpointPageSequence + 1;
@@ -217,25 +217,25 @@ static int yaffs_CheckpointFlushBuffer(yaffs_Device *dev)
                bi->blockState = YAFFS_BLOCK_STATE_CHECKPOINT;
                dev->blocksInCheckpoint++;
        }
-       
+
        chunk = dev->checkpointCurrentBlock * dev->nChunksPerBlock + dev->checkpointCurrentChunk;
 
-       
+
        T(YAFFS_TRACE_CHECKPOINT,(TSTR("checkpoint wite buffer nand %d(%d:%d) objid %d chId %d" TENDSTR),
-               chunk, dev->checkpointCurrentBlock, dev->checkpointCurrentChunk,tags.objectId,tags.chunkId)); 
-       
+               chunk, dev->checkpointCurrentBlock, dev->checkpointCurrentChunk,tags.objectId,tags.chunkId));
+
        realignedChunk = chunk - dev->chunkOffset;
-       
+
        dev->writeChunkWithTagsToNAND(dev,realignedChunk,dev->checkpointBuffer,&tags);
        dev->checkpointByteOffset = 0;
-       dev->checkpointPageSequence++;     
+       dev->checkpointPageSequence++;
        dev->checkpointCurrentChunk++;
        if(dev->checkpointCurrentChunk >= dev->nChunksPerBlock){
                dev->checkpointCurrentChunk = 0;
                dev->checkpointCurrentBlock = -1;
        }
        memset(dev->checkpointBuffer,0,dev->nDataBytesPerChunk);
-       
+
        return 1;
 }
 
@@ -245,37 +245,37 @@ int yaffs_CheckpointWrite(yaffs_Device *dev,const void *data, int nBytes)
        int i=0;
        int ok = 1;
 
-       
+
        __u8 * dataBytes = (__u8 *)data;
-       
-       
+
+
 
        if(!dev->checkpointBuffer)
                return 0;
-               
+
        if(!dev->checkpointOpenForWrite)
                return -1;
 
        while(i < nBytes && ok) {
-               
 
-               
+
+
                dev->checkpointBuffer[dev->checkpointByteOffset] = *dataBytes ;
                dev->checkpointSum += *dataBytes;
                dev->checkpointXor ^= *dataBytes;
-                
+
                dev->checkpointByteOffset++;
                i++;
                dataBytes++;
                dev->checkpointByteCount++;
-               
-               
+
+
                if(dev->checkpointByteOffset < 0 ||
-                  dev->checkpointByteOffset >= dev->nDataBytesPerChunk) 
+                  dev->checkpointByteOffset >= dev->nDataBytesPerChunk)
                        ok = yaffs_CheckpointFlushBuffer(dev);
 
        }
-       
+
        return  i;
 }
 
@@ -285,12 +285,12 @@ int yaffs_CheckpointRead(yaffs_Device *dev, void *data, int nBytes)
        int ok = 1;
        yaffs_ExtendedTags tags;
 
-       
+
        int chunk;
        int realignedChunk;
 
        __u8 *dataBytes = (__u8 *)data;
-               
+
        if(!dev->checkpointBuffer)
                return 0;
 
@@ -298,31 +298,31 @@ int yaffs_CheckpointRead(yaffs_Device *dev, void *data, int nBytes)
                return -1;
 
        while(i < nBytes && ok) {
-       
-       
+
+
                if(dev->checkpointByteOffset < 0 ||
                   dev->checkpointByteOffset >= dev->nDataBytesPerChunk) {
-                  
+
                        if(dev->checkpointCurrentBlock < 0){
                                yaffs_CheckpointFindNextCheckpointBlock(dev);
                                dev->checkpointCurrentChunk = 0;
                        }
-                       
+
                        if(dev->checkpointCurrentBlock < 0)
                                ok = 0;
                        else {
-                       
-                               chunk = dev->checkpointCurrentBlock * dev->nChunksPerBlock + 
+
+                               chunk = dev->checkpointCurrentBlock * dev->nChunksPerBlock +
                                          dev->checkpointCurrentChunk;
 
                                realignedChunk = chunk - dev->chunkOffset;
 
                                /* read in the next chunk */
                                /* printf("read checkpoint page %d\n",dev->checkpointPage); */
-                               dev->readChunkWithTagsFromNAND(dev, realignedChunk, 
+                               dev->readChunkWithTagsFromNAND(dev, realignedChunk,
                                                               dev->checkpointBuffer,
                                                              &tags);
-                                                     
+
                                if(tags.chunkId != (dev->checkpointPageSequence + 1) ||
                                   tags.sequenceNumber != YAFFS_SEQUENCE_CHECKPOINT_DATA)
                                   ok = 0;
@@ -330,12 +330,12 @@ int yaffs_CheckpointRead(yaffs_Device *dev, void *data, int nBytes)
                                dev->checkpointByteOffset = 0;
                                dev->checkpointPageSequence++;
                                dev->checkpointCurrentChunk++;
-                       
+
                                if(dev->checkpointCurrentChunk >= dev->nChunksPerBlock)
                                        dev->checkpointCurrentBlock = -1;
                        }
                }
-               
+
                if(ok){
                        *dataBytes = dev->checkpointBuffer[dev->checkpointByteOffset];
                        dev->checkpointSum += *dataBytes;
@@ -346,14 +346,14 @@ int yaffs_CheckpointRead(yaffs_Device *dev, void *data, int nBytes)
                        dev->checkpointByteCount++;
                }
        }
-       
+
        return  i;
 }
 
 int yaffs_CheckpointClose(yaffs_Device *dev)
 {
 
-       if(dev->checkpointOpenForWrite){        
+       if(dev->checkpointOpenForWrite){
                if(dev->checkpointByteOffset != 0)
                        yaffs_CheckpointFlushBuffer(dev);
        } else {
@@ -373,19 +373,19 @@ int yaffs_CheckpointClose(yaffs_Device *dev)
        dev->nFreeChunks -= dev->blocksInCheckpoint * dev->nChunksPerBlock;
        dev->nErasedBlocks -= dev->blocksInCheckpoint;
 
-               
+
        T(YAFFS_TRACE_CHECKPOINT,(TSTR("checkpoint byte count %d" TENDSTR),
                        dev->checkpointByteCount));
-                       
+
        if(dev->checkpointBuffer){
-               /* free the buffer */   
+               /* free the buffer */
                YFREE(dev->checkpointBuffer);
                dev->checkpointBuffer = NULL;
                return 1;
        }
        else
                return 0;
-       
+
 }
 
 int yaffs_CheckpointInvalidateStream(yaffs_Device *dev)
index f4b0c7dcaaf4b03e967179df46bf3b44c8e975f0..d3ff17405f2df9409ed5516064deddadea70bcf4 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
index be860d01a6f3853695efb2a9184bb43ffe728927..e2860393d3726d5b7709afaf0b2a427e59f215e1 100644 (file)
@@ -14,9 +14,9 @@
 /*
  * This code implements the ECC algorithm used in SmartMedia.
  *
- * The ECC comprises 22 bits of parity information and is stuffed into 3 bytes. 
+ * The ECC comprises 22 bits of parity information and is stuffed into 3 bytes.
  * The two unused bit are set to 1.
- * The ECC can correct single bit errors in a 256-byte page of data. Thus, two such ECC 
+ * The ECC can correct single bit errors in a 256-byte page of data. Thus, two such ECC
  * blocks are used on a 512-byte NAND page.
  *
  */
@@ -228,8 +228,8 @@ int yaffs_ECCCorrect(unsigned char *data, unsigned char *read_ecc,
                return 1; /* Corrected the error */
        }
 
-       if ((yaffs_CountBits(d0) + 
-            yaffs_CountBits(d1) + 
+       if ((yaffs_CountBits(d0) +
+            yaffs_CountBits(d1) +
             yaffs_CountBits(d2)) ==  1) {
                /* Reccoverable error in ecc */
 
@@ -239,7 +239,7 @@ int yaffs_ECCCorrect(unsigned char *data, unsigned char *read_ecc,
 
                return 1; /* Corrected the error */
        }
-       
+
        /* Unrecoverable error */
 
        return -1;
@@ -293,7 +293,7 @@ int yaffs_ECCCorrectOther(unsigned char *data, unsigned nBytes,
        if ((cDelta | lDelta | lDeltaPrime) == 0)
                return 0; /* no error */
 
-       if (lDelta == ~lDeltaPrime && 
+       if (lDelta == ~lDeltaPrime &&
            (((cDelta ^ (cDelta >> 1)) & 0x15) == 0x15))
        {
                /* Single bit (recoverable) error in data */
@@ -309,7 +309,7 @@ int yaffs_ECCCorrectOther(unsigned char *data, unsigned nBytes,
 
                if(lDelta >= nBytes)
                        return -1;
-                       
+
                data[lDelta] ^= (1 << bit);
 
                return 1; /* corrected */
index 40fd02b9653ec750fe66ce4f991a3121e0310415..79bc3d117146d4d08f823dca2ec3700cc0c9bf9e 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
@@ -16,9 +16,9 @@
  /*
   * This code implements the ECC algorithm used in SmartMedia.
   *
-  * The ECC comprises 22 bits of parity information and is stuffed into 3 bytes. 
+  * The ECC comprises 22 bits of parity information and is stuffed into 3 bytes.
   * The two unused bit are set to 1.
-  * The ECC can correct single bit errors in a 256-byte page of data. Thus, two such ECC 
+  * The ECC can correct single bit errors in a 256-byte page of data. Thus, two such ECC
   * blocks are used on a 512-byte NAND page.
   *
   */
index e572301f5d1956a3b81970bb4f3bf7a07e52f26c..67001b10e667f3c07751ec8570a6316b134dcd20 100644 (file)
@@ -23,7 +23,7 @@
  * This is the file system front-end to YAFFS that hooks it up to
  * the VFS.
  *
- * Special notes: 
+ * Special notes:
  * >> 2.4: sb->u.generic_sbp points to the yaffs_Device associated with
  *         this superblock
  * >> 2.6: sb->s_fs_info  points to the yaffs_Device associated with this
@@ -391,7 +391,7 @@ static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry)
                                   dentry->d_name.name);
 
        obj = yaffs_GetEquivalentObject(obj);   /* in case it was a hardlink */
-       
+
        /* Can't hold gross lock when calling yaffs_get_inode() */
        yaffs_GrossUnlock(dev);
 
@@ -729,21 +729,21 @@ static void yaffs_FillInodeFromObject(struct inode *inode, yaffs_Object * obj)
                                obj->yst_mode &= ~S_IFMT;
                                obj->yst_mode |= S_IFREG;
                        }
+
                        break;
                case YAFFS_OBJECT_TYPE_SYMLINK :
                        if( ! S_ISLNK(mode) ){
                                obj->yst_mode &= ~S_IFMT;
                                obj->yst_mode |= S_IFLNK;
                        }
+
                        break;
                case YAFFS_OBJECT_TYPE_DIRECTORY :
                        if( ! S_ISDIR(mode) ){
                                obj->yst_mode &= ~S_IFMT;
                                obj->yst_mode |= S_IFDIR;
                        }
+
                        break;
                case YAFFS_OBJECT_TYPE_UNKNOWN :
                case YAFFS_OBJECT_TYPE_HARDLINK :
@@ -1020,7 +1020,7 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
        int error = -ENOSPC;
        uid_t uid = current->fsuid;
        gid_t gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->fsgid;
-       
+
        if((dir->i_mode & S_ISGID) && S_ISDIR(mode))
                mode |= S_ISGID;
 
@@ -1075,7 +1075,7 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
                obj = NULL;     /* Do we ever get here? */
                break;
        }
-       
+
        /* Can not call yaffs_get_inode() with gross lock held */
        yaffs_GrossUnlock(dev);
 
@@ -1264,13 +1264,13 @@ static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry,
        target =
            yaffs_FindObjectByName(yaffs_InodeToObject(new_dir),
                                   new_dentry->d_name.name);
-       
-       
+
+
 
        if (target &&
            target->variantType == YAFFS_OBJECT_TYPE_DIRECTORY &&
            !list_empty(&target->variant.directoryVariant.children)) {
-           
+
                T(YAFFS_TRACE_OS, (KERN_DEBUG "target is non-empty dir\n"));
 
                retVal = YAFFS_FAIL;
@@ -1278,7 +1278,7 @@ static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry,
 
                /* Now does unlinking internally using shadowing mechanism */
                T(YAFFS_TRACE_OS, (KERN_DEBUG "calling yaffs_RenameObject\n"));
-               
+
                retVal =
                    yaffs_RenameObject(yaffs_InodeToObject(old_dir),
                                       old_dentry->d_name.name,
@@ -1390,7 +1390,7 @@ static int yaffs_do_sync_fs(struct super_block *sb)
 
                if(dev)
                        yaffs_CheckpointSave(dev);
-               
+
                yaffs_GrossUnlock(dev);
 
                sb->s_dirt = 0;
@@ -1421,16 +1421,16 @@ static int yaffs_sync_fs(struct super_block *sb)
 {
 
        T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_sync_fs\n"));
-       
+
        return 0; /* yaffs_do_sync_fs(sb);*/
-       
+
 }
 
 
 static void yaffs_read_inode(struct inode *inode)
 {
        /* NB This is called as a side effect of other functions, but
-        * we had to release the lock to prevent deadlocks, so 
+        * we had to release the lock to prevent deadlocks, so
         * need to lock again.
         */
 
@@ -1441,7 +1441,7 @@ static void yaffs_read_inode(struct inode *inode)
          (KERN_DEBUG "yaffs_read_inode for %d\n", (int)inode->i_ino));
 
        yaffs_GrossLock(dev);
-       
+
        obj = yaffs_FindObjectByNumber(dev, inode->i_ino);
 
        yaffs_FillInodeFromObject(inode, obj);
@@ -1458,26 +1458,26 @@ static int yaffs_remount_fs(struct super_block *sb, int *flags, char *data)
 
        if( *flags & MS_RDONLY ) {
                struct mtd_info *mtd = yaffs_SuperToDevice(sb)->genericDevice;
-           
+
                T(YAFFS_TRACE_OS,
                        (KERN_DEBUG "yaffs_remount_fs: %s: RO\n", dev->name ));
 
                yaffs_GrossLock(dev);
-        
+
                yaffs_FlushEntireDeviceCache(dev);
-       
+
                yaffs_CheckpointSave(dev);
+
                if (mtd->sync)
                        mtd->sync(mtd);
 
                yaffs_GrossUnlock(dev);
        }
        else {
-               T(YAFFS_TRACE_OS, 
+               T(YAFFS_TRACE_OS,
                        (KERN_DEBUG "yaffs_remount_fs: %s: RW\n", dev->name ));
        }
+
        return 0;
 }
 #endif
@@ -1489,7 +1489,7 @@ static void yaffs_put_super(struct super_block *sb)
        T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_put_super\n"));
 
        yaffs_GrossLock(dev);
-       
+
        yaffs_FlushEntireDeviceCache(dev);
 
        yaffs_CheckpointSave(dev);
@@ -1499,12 +1499,12 @@ static void yaffs_put_super(struct super_block *sb)
        }
 
        yaffs_Deinitialise(dev);
-       
+
        yaffs_GrossUnlock(dev);
 
        /* we assume this is protected by lock_kernel() in mount/umount */
        list_del(&dev->devList);
-       
+
        if(dev->spareBuffer){
                YFREE(dev->spareBuffer);
                dev->spareBuffer = NULL;
@@ -1530,7 +1530,7 @@ static void yaffs_MTDPutSuper(struct super_block *sb)
 static void yaffs_MarkSuperBlockDirty(void *vsb)
 {
        struct super_block *sb = (struct super_block *)vsb;
-       
+
        T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_MarkSuperBlockDirty() sb = %p\n",sb));
 //     if(sb)
 //             sb->s_dirt = 1;
@@ -1549,13 +1549,13 @@ static int yaffs_parse_options(yaffs_options *options, const char *options_str)
        char cur_opt[MAX_OPT_LEN+1];
        int p;
        int error = 0;
-       
+
        /* Parse through the options which is a comma seperated list */
-       
+
        while(options_str && *options_str && !error){
                memset(cur_opt,0,MAX_OPT_LEN+1);
                p = 0;
-               
+
                while(*options_str && *options_str != ','){
                        if(p < MAX_OPT_LEN){
                                cur_opt[p] = *options_str;
@@ -1563,7 +1563,7 @@ static int yaffs_parse_options(yaffs_options *options, const char *options_str)
                        }
                        options_str++;
                }
-               
+
                if(!strcmp(cur_opt,"inband-tags"))
                        options->inband_tags = 1;
                else if(!strcmp(cur_opt,"no-cache"))
@@ -1579,7 +1579,7 @@ static int yaffs_parse_options(yaffs_options *options, const char *options_str)
                        printk(KERN_INFO "yaffs: Bad mount option \"%s\"\n",cur_opt);
                        error = 1;
                }
-               
+
        }
 
        return error;
@@ -1597,7 +1597,7 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion,
        struct mtd_info *mtd;
        int err;
        char *data_str = (char *)data;
-       
+
        yaffs_options options;
 
        sb->s_magic = YAFFS_MAGIC;
@@ -1613,14 +1613,14 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion,
                printk(KERN_INFO "yaffs: dev is %d name is \"%s\"\n",
                       sb->s_dev,
                       yaffs_devname(sb, devname_buf));
-                   
+
        if(!data_str)
                data_str = "";
-   
+
        printk(KERN_INFO "yaffs: passed flags \"%s\"\n",data_str);
-       
+
        memset(&options,0,sizeof(options));
-       
+
        if(yaffs_parse_options(&options,data_str)){
                /* Option parsing failed */
                return NULL;
@@ -1674,10 +1674,10 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion,
        T(YAFFS_TRACE_OS, (" oobsize %d\n", mtd->oobsize));
        T(YAFFS_TRACE_OS, (" erasesize %d\n", mtd->erasesize));
        T(YAFFS_TRACE_OS, (" size %d\n", mtd->size));
-       
+
 #ifdef CONFIG_YAFFS_AUTO_YAFFS2
 
-       if (yaffsVersion == 1 && 
+       if (yaffsVersion == 1 &&
 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
            mtd->writesize >= 2048) {
 #else
@@ -1685,10 +1685,10 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion,
 #endif
            T(YAFFS_TRACE_ALWAYS,("yaffs: auto selecting yaffs2\n"));
            yaffsVersion = 2;
-       }       
-       
+       }
+
        /* Added NCB 26/5/2006 for completeness */
-       if (yaffsVersion == 2 && 
+       if (yaffsVersion == 2 &&
 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
            mtd->writesize == 512) {
 #else
@@ -1696,7 +1696,7 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion,
 #endif
            T(YAFFS_TRACE_ALWAYS,("yaffs: auto selecting yaffs1\n"));
            yaffsVersion = 1;
-       }       
+       }
 
 #endif
 
@@ -1830,10 +1830,10 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion,
        dev->initialiseNAND = nandmtd_InitialiseNAND;
 
        dev->putSuperFunc = yaffs_MTDPutSuper;
-       
+
        dev->superBlock = (void *)sb;
        dev->markSuperBlockDirty = yaffs_MarkSuperBlockDirty;
-       
+
 
 #ifndef CONFIG_YAFFS_DOES_ECC
        dev->useNANDECC = 1;
@@ -1845,7 +1845,7 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion,
 
        dev->skipCheckpointRead = options.skip_checkpoint_read;
        dev->skipCheckpointWrite = options.skip_checkpoint_write;
-       
+
        /* we assume this is protected by lock_kernel() in mount/umount */
        list_add_tail(&dev->devList, &yaffs_dev_list);
 
@@ -1858,7 +1858,7 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion,
        T(YAFFS_TRACE_OS,
          ("yaffs_read_super: guts initialised %s\n",
           (err == YAFFS_OK) ? "OK" : "FAILED"));
-       
+
        /* Release lock before yaffs_get_inode() */
        yaffs_GrossUnlock(dev);
 
@@ -2118,7 +2118,7 @@ static int yaffs_proc_write(struct file *file, const char *buf,
        unsigned rg = 0, mask_bitfield;
        char *end;
        char *mask_name;
-       const char *x; 
+       const char *x;
        char substring[MAX_MASK_NAME_LENGTH+1];
        int i;
        int done = 0;
@@ -2146,7 +2146,7 @@ static int yaffs_proc_write(struct file *file, const char *buf,
                        break;
                }
                mask_name = NULL;
-               
+
                mask_bitfield = simple_strtoul(buf + pos, &end, 0);
                if (end > buf + pos) {
                        mask_name = "numeral";
@@ -2154,12 +2154,12 @@ static int yaffs_proc_write(struct file *file, const char *buf,
                        pos += len;
                        done = 0;
                } else {
-                       for(x = buf + pos, i = 0; 
+                       for(x = buf + pos, i = 0;
                            (*x == '_' || (*x >='a' && *x <= 'z')) &&
                            i <MAX_MASK_NAME_LENGTH; x++, i++, pos++)
                            substring[i] = *x;
                        substring[i] = '\0';
-                       
+
                        for (i = 0; mask_flags[i].mask_name != NULL; i++) {
                                if(strcmp(substring,mask_flags[i].mask_name) == 0){
                                        mask_name = mask_flags[i].mask_name;
@@ -2190,9 +2190,9 @@ static int yaffs_proc_write(struct file *file, const char *buf,
        }
 
        yaffs_traceMask = rg | YAFFS_TRACE_ALWAYS;
-       
+
        printk("new trace = 0x%08X\n",yaffs_traceMask);
-       
+
        if (rg & YAFFS_TRACE_ALWAYS) {
                for (i = 0; mask_flags[i].mask_name != NULL; i++) {
                        char flag;
index 006820c7136e88b226f2386ea79e8836cd391460..2ab814691356d3e8cd68e0c8cea1ab660bfc4df4 100644 (file)
@@ -140,71 +140,71 @@ static void yaffs_AddrToChunk(yaffs_Device *dev, loff_t addr, __u32 *chunk, __u3
                YBUG();
 }
 
-/* Function to return the number of shifts for a power of 2 greater than or equal 
+/* Function to return the number of shifts for a power of 2 greater than or equal
  * to the given number
  * Note we don't try to cater for all possible numbers and this does not have to
  * be hellishly efficient.
  */
+
 static __u32 ShiftsGE(__u32 x)
 {
        int extraBits;
        int nShifts;
-       
+
        nShifts = extraBits = 0;
-       
+
        while(x>1){
                if(x & 1) extraBits++;
                x>>=1;
                nShifts++;
        }
 
-       if(extraBits) 
+       if(extraBits)
                nShifts++;
-               
+
        return nShifts;
 }
 
 /* Function to return the number of shifts to get a 1 in bit 0
  */
+
 static __u32 ShiftDiv(__u32 x)
 {
        int nShifts;
-       
+
        nShifts =  0;
-       
+
        if(!x) return 0;
-       
+
        while( !(x&1)){
                x>>=1;
                nShifts++;
        }
-               
+
        return nShifts;
 }
 
 
 
-/* 
+/*
  * Temporary buffer manipulations.
  */
 
-static int yaffs_InitialiseTempBuffers(yaffs_Device *dev)      
+static int yaffs_InitialiseTempBuffers(yaffs_Device *dev)
 {
        int i;
        __u8 *buf = (__u8 *)1;
-               
+
        memset(dev->tempBuffer,0,sizeof(dev->tempBuffer));
-               
+
        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->nDataBytesPerChunk);
        }
-               
+
        return buf ? YAFFS_OK : YAFFS_FAIL;
-       
+
 }
 
 static __u8 *yaffs_GetTempBuffer(yaffs_Device * dev, int lineNo)
@@ -337,7 +337,7 @@ static Y_INLINE void yaffs_ClearChunkBit(yaffs_Device * dev, int blk, int chunk)
 static Y_INLINE void yaffs_SetChunkBit(yaffs_Device * dev, int blk, int chunk)
 {
        __u8 *blkBits = yaffs_BlockBits(dev, blk);
-       
+
        yaffs_VerifyChunkBitId(dev,blk,chunk);
 
        blkBits[chunk / 8] |= (1 << (chunk & 7));
@@ -375,16 +375,16 @@ static int yaffs_CountChunkBits(yaffs_Device * dev, int blk)
                                n++;
                        x >>=1;
                }
-                       
+
                blkBits++;
        }
        return n;
 }
 
-/* 
+/*
  * Verification code
  */
+
 static int yaffs_SkipVerification(yaffs_Device *dev)
 {
        return !(yaffs_traceMask & (YAFFS_TRACE_VERIFY | YAFFS_TRACE_VERIFY_FULL));
@@ -417,14 +417,14 @@ static void yaffs_VerifyBlock(yaffs_Device *dev,yaffs_BlockInfo *bi,int n)
 {
        int actuallyUsed;
        int inUse;
-       
+
        if(yaffs_SkipVerification(dev))
                return;
-               
+
        /* Report illegal runtime states */
        if(bi->blockState <0 || bi->blockState >= YAFFS_NUMBER_OF_BLOCK_STATES)
                T(YAFFS_TRACE_VERIFY,(TSTR("Block %d has undefined state %d"TENDSTR),n,bi->blockState));
-               
+
        switch(bi->blockState){
         case YAFFS_BLOCK_STATE_UNKNOWN:
         case YAFFS_BLOCK_STATE_SCANNING:
@@ -432,42 +432,42 @@ static void yaffs_VerifyBlock(yaffs_Device *dev,yaffs_BlockInfo *bi,int n)
                T(YAFFS_TRACE_VERIFY,(TSTR("Block %d has bad run-state %s"TENDSTR),
                n,blockStateName[bi->blockState]));
        }
-       
+
        /* Check pages in use and soft deletions are legal */
-       
+
        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)
                T(YAFFS_TRACE_VERIFY,(TSTR("Block %d has illegal values pagesInUsed %d softDeletions %d"TENDSTR),
                n,bi->pagesInUse,bi->softDeletions));
-       
-               
+
+
        /* Check chunk bitmap legal */
        inUse = yaffs_CountChunkBits(dev,n);
        if(inUse != bi->pagesInUse)
                T(YAFFS_TRACE_VERIFY,(TSTR("Block %d has inconsistent values pagesInUse %d counted chunk bits %d"TENDSTR),
                        n,bi->pagesInUse,inUse));
-       
+
        /* Check that the sequence number is valid.
-        * Ten million is legal, but is very unlikely 
+        * Ten million is legal, but is very unlikely
         */
-       if(dev->isYaffs2 && 
+       if(dev->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),
                n,bi->sequenceNumber));
-               
+
 }
 
 static void yaffs_VerifyCollectedBlock(yaffs_Device *dev,yaffs_BlockInfo *bi,int n)
 {
        yaffs_VerifyBlock(dev,bi,n);
-       
+
        /* After collection the block should be in the erased state */
        /* TODO: This will need to change if we do partial gc */
-       
+
        if(bi->blockState != YAFFS_BLOCK_STATE_EMPTY){
                T(YAFFS_TRACE_ERROR,(TSTR("Block %d is in state %d after gc, should be erased"TENDSTR),
                        n,bi->blockState));
@@ -479,14 +479,14 @@ static void yaffs_VerifyBlocks(yaffs_Device *dev)
        int i;
        int nBlocksPerState[YAFFS_NUMBER_OF_BLOCK_STATES];
        int nIllegalBlockStates = 0;
-       
+
 
        if(yaffs_SkipVerification(dev))
                return;
 
        memset(nBlocksPerState,0,sizeof(nBlocksPerState));
 
-               
+
        for(i = dev->internalStartBlock; i <= dev->internalEndBlock; i++){
                yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev,i);
                yaffs_VerifyBlock(dev,bi,i);
@@ -495,12 +495,12 @@ static void yaffs_VerifyBlocks(yaffs_Device *dev)
                        nBlocksPerState[bi->blockState]++;
                else
                        nIllegalBlockStates++;
-                                       
+
        }
-       
+
        T(YAFFS_TRACE_VERIFY,(TSTR(""TENDSTR)));
        T(YAFFS_TRACE_VERIFY,(TSTR("Block summary"TENDSTR)));
-       
+
        T(YAFFS_TRACE_VERIFY,(TSTR("%d blocks have illegal states"TENDSTR),nIllegalBlockStates));
        if(nBlocksPerState[YAFFS_BLOCK_STATE_ALLOCATING] > 1)
                T(YAFFS_TRACE_VERIFY,(TSTR("Too many allocating blocks"TENDSTR)));
@@ -509,17 +509,17 @@ static void yaffs_VerifyBlocks(yaffs_Device *dev)
                T(YAFFS_TRACE_VERIFY,
                  (TSTR("%s %d blocks"TENDSTR),
                  blockStateName[i],nBlocksPerState[i]));
-       
+
        if(dev->blocksInCheckpoint != nBlocksPerState[YAFFS_BLOCK_STATE_CHECKPOINT])
                T(YAFFS_TRACE_VERIFY,
                 (TSTR("Checkpoint block count wrong dev %d count %d"TENDSTR),
                 dev->blocksInCheckpoint, nBlocksPerState[YAFFS_BLOCK_STATE_CHECKPOINT]));
-                
+
        if(dev->nErasedBlocks != nBlocksPerState[YAFFS_BLOCK_STATE_EMPTY])
                T(YAFFS_TRACE_VERIFY,
                 (TSTR("Erased block count wrong dev %d count %d"TENDSTR),
                 dev->nErasedBlocks, nBlocksPerState[YAFFS_BLOCK_STATE_EMPTY]));
-                
+
        if(nBlocksPerState[YAFFS_BLOCK_STATE_COLLECTING] > 1)
                T(YAFFS_TRACE_VERIFY,
                 (TSTR("Too many collecting blocks %d (max is 1)"TENDSTR),
@@ -537,14 +537,14 @@ static void yaffs_VerifyObjectHeader(yaffs_Object *obj, yaffs_ObjectHeader *oh,
 {
        if(yaffs_SkipVerification(obj->myDev))
                return;
-               
+
        if(!(tags && obj && oh)){
                T(YAFFS_TRACE_VERIFY,
                                (TSTR("Verifying object header tags %x obj %x oh %x"TENDSTR),
                                (__u32)tags,(__u32)obj,(__u32)oh));
                return;
        }
-       
+
        if(oh->type <= YAFFS_OBJECT_TYPE_UNKNOWN ||
           oh->type > YAFFS_OBJECT_TYPE_MAX)
                T(YAFFS_TRACE_VERIFY,
@@ -559,25 +559,25 @@ static void yaffs_VerifyObjectHeader(yaffs_Object *obj, yaffs_ObjectHeader *oh,
 
        /*
         * Check that the object's parent ids match if parentCheck requested.
-        * 
+        *
         * Tests do not apply to the root object.
         */
-       
+
        if(parentCheck && tags->objectId > 1 && !obj->parent)
                T(YAFFS_TRACE_VERIFY,
                 (TSTR("Obj %d header mismatch parentId %d obj->parent is NULL"TENDSTR),
                 tags->objectId, oh->parentObjectId));
-               
-       
+
+
        if(parentCheck && obj->parent &&
-          oh->parentObjectId != obj->parent->objectId && 
+          oh->parentObjectId != obj->parent->objectId &&
           (oh->parentObjectId != YAFFS_OBJECTID_UNLINKED ||
            obj->parent->objectId != YAFFS_OBJECTID_DELETED))
                T(YAFFS_TRACE_VERIFY,
                 (TSTR("Obj %d header mismatch parentId %d parentObjectId %d"TENDSTR),
                 tags->objectId, oh->parentObjectId, obj->parent->objectId));
-               
-       
+
+
        if(tags->objectId > 1 && oh->name[0] == 0) /* Null name */
                T(YAFFS_TRACE_VERIFY,
                (TSTR("Obj %d header name is NULL"TENDSTR),
@@ -614,12 +614,12 @@ static int yaffs_VerifyTnodeWorker(yaffs_Object * obj, yaffs_Tnode * tn,
                        int i;
                        yaffs_ExtendedTags tags;
                        __u32 objectId = obj->objectId;
-                       
+
                        chunkOffset <<=  YAFFS_TNODES_LEVEL0_BITS;
-                       
+
                        for(i = 0; i < YAFFS_NTNODES_LEVEL0; i++){
                                __u32 theChunk = yaffs_GetChunkGroupBase(dev,tn,i);
-                               
+
                                if(theChunk > 0){
                                        /* T(~0,(TSTR("verifying (%d:%d) %d"TENDSTR),tags.objectId,tags.chunkId,theChunk)); */
                                        yaffs_ReadChunkWithTagsFromNAND(dev,theChunk,NULL, &tags);
@@ -651,13 +651,13 @@ static void yaffs_VerifyFile(yaffs_Object *obj)
        yaffs_ExtendedTags tags;
        yaffs_Tnode *tn;
        __u32 objectId;
-       
+
        if(obj && yaffs_SkipVerification(obj->myDev))
                return;
-       
+
        dev = obj->myDev;
        objectId = obj->objectId;
-       
+
        /* Check file size is consistent with tnode depth */
        lastChunk =  obj->variant.fileVariant.fileSize / dev->nDataBytesPerChunk + 1;
        x = lastChunk >> YAFFS_TNODES_LEVEL0_BITS;
@@ -666,23 +666,23 @@ static void yaffs_VerifyFile(yaffs_Object *obj)
                x >>= YAFFS_TNODES_INTERNAL_BITS;
                requiredTallness++;
        }
-       
+
        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. 
+
+
+       /* 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.
         */
 
        if(yaffs_SkipNANDVerification(dev))
                return;
-               
+
        for(i = 1; i <= lastChunk; i++){
                tn = yaffs_FindLevel0Tnode(dev, &obj->variant.fileVariant,i);
 
@@ -707,14 +707,14 @@ static void yaffs_VerifyDirectory(yaffs_Object *obj)
 {
        if(obj && yaffs_SkipVerification(obj->myDev))
                return;
-       
+
 }
 
 static void yaffs_VerifyHardLink(yaffs_Object *obj)
 {
        if(obj && yaffs_SkipVerification(obj->myDev))
                return;
-               
+
        /* Verify sane equivalent object */
 }
 
@@ -722,7 +722,7 @@ static void yaffs_VerifySymlink(yaffs_Object *obj)
 {
        if(obj && yaffs_SkipVerification(obj->myDev))
                return;
-               
+
        /* Verify symlink string */
 }
 
@@ -735,32 +735,32 @@ static void yaffs_VerifySpecial(yaffs_Object *obj)
 static void yaffs_VerifyObject(yaffs_Object *obj)
 {
        yaffs_Device *dev;
-       
+
        __u32 chunkMin;
        __u32 chunkMax;
-       
+
        __u32 chunkIdOk;
        __u32 chunkIsLive;
-       
+
        if(!obj)
                return;
-       
+
        dev = obj->myDev;
-       
+
        if(yaffs_SkipVerification(dev))
                return;
-               
+
        /* Check sane object header chunk */
-       
+
        chunkMin = dev->internalStartBlock * dev->nChunksPerBlock;
        chunkMax = (dev->internalEndBlock+1) * dev->nChunksPerBlock - 1;
-       
+
        chunkIdOk = (obj->chunkId >= chunkMin && obj->chunkId <= chunkMax);
-       chunkIsLive = chunkIdOk && 
-                       yaffs_CheckChunkBit(dev, 
+       chunkIsLive = chunkIdOk &&
+                       yaffs_CheckChunkBit(dev,
                                            obj->chunkId / dev->nChunksPerBlock,
                                            obj->chunkId % dev->nChunksPerBlock);
-       if(!obj->fake && 
+       if(!obj->fake &&
            (!chunkIdOk || !chunkIsLive)) {
           T(YAFFS_TRACE_VERIFY,
           (TSTR("Obj %d has chunkId %d %s %s"TENDSTR),
@@ -768,36 +768,36 @@ static void yaffs_VerifyObject(yaffs_Object *obj)
           chunkIdOk ? "" : ",out of range",
           chunkIsLive || !chunkIdOk ? "" : ",marked as deleted"));
        }
-       
+
        if(chunkIdOk && chunkIsLive &&!yaffs_SkipNANDVerification(dev)) {
                yaffs_ExtendedTags tags;
                yaffs_ObjectHeader *oh;
                __u8 *buffer = yaffs_GetTempBuffer(dev,__LINE__);
-               
+
                oh = (yaffs_ObjectHeader *)buffer;
-               
+
                yaffs_ReadChunkWithTagsFromNAND(dev, obj->chunkId,buffer, &tags);
-               
+
                yaffs_VerifyObjectHeader(obj,oh,&tags,1);
-               
+
                yaffs_ReleaseTempBuffer(dev,buffer,__LINE__);
        }
-       
+
        /* Verify it has a parent */
        if(obj && !obj->fake &&
           (!obj->parent || obj->parent->myDev != dev)){
           T(YAFFS_TRACE_VERIFY,
           (TSTR("Obj %d has parent pointer %p which does not look like an object"TENDSTR),
-          obj->objectId,obj->parent));    
+          obj->objectId,obj->parent));
        }
-       
+
        /* Verify parent is a directory */
        if(obj->parent && obj->parent->variantType != YAFFS_OBJECT_TYPE_DIRECTORY){
           T(YAFFS_TRACE_VERIFY,
           (TSTR("Obj %d's parent is not a directory (type %d)"TENDSTR),
-          obj->objectId,obj->parent->variantType));       
+          obj->objectId,obj->parent->variantType));
        }
-       
+
        switch(obj->variantType){
        case YAFFS_OBJECT_TYPE_FILE:
                yaffs_VerifyFile(obj);
@@ -818,11 +818,11 @@ static void yaffs_VerifyObject(yaffs_Object *obj)
        default:
                T(YAFFS_TRACE_VERIFY,
                (TSTR("Obj %d has illegaltype %d"TENDSTR),
-               obj->objectId,obj->variantType));          
+               obj->objectId,obj->variantType));
                break;
        }
-       
-       
+
+
 }
 
 static void yaffs_VerifyObjects(yaffs_Device *dev)
@@ -833,9 +833,9 @@ static void yaffs_VerifyObjects(yaffs_Device *dev)
 
        if(yaffs_SkipVerification(dev))
                return;
-       
+
        /* Iterate through the objects in each hash entry */
-        
+
         for(i = 0; i <  YAFFS_NOBJECT_BUCKETS; i++){
                list_for_each(lh, &dev->objectBucket[i].list) {
                        if (lh) {
@@ -851,7 +851,7 @@ static void yaffs_VerifyObjects(yaffs_Device *dev)
 /*
  *  Simple hash function. Needs to have a reasonable spread
  */
+
 static Y_INLINE int yaffs_HashFunction(int n)
 {
        n = abs(n);
@@ -861,7 +861,7 @@ static Y_INLINE int yaffs_HashFunction(int n)
 /*
  * Access functions to useful fake objects
  */
+
 yaffs_Object *yaffs_Root(yaffs_Device * dev)
 {
        return dev->rootDir;
@@ -876,7 +876,7 @@ yaffs_Object *yaffs_LostNFound(yaffs_Device * dev)
 /*
  *  Erased NAND checking functions
  */
+
 int yaffs_CheckFF(__u8 * buffer, int nBytes)
 {
        /* Horrible, slow implementation */
@@ -898,10 +898,10 @@ static int yaffs_CheckChunkErased(struct yaffs_DeviceStruct *dev,
        int result;
 
        result = yaffs_ReadChunkWithTagsFromNAND(dev, chunkInNAND, data, &tags);
-       
+
        if(tags.eccResult > YAFFS_ECC_RESULT_NO_ERROR)
                retval = YAFFS_FAIL;
-               
+
 
        if (!yaffs_CheckFF(data, dev->nDataBytesPerChunk) || tags.chunkUsed) {
                T(YAFFS_TRACE_NANDACCESS,
@@ -1008,13 +1008,13 @@ static int yaffs_WriteNewChunkWithTagsToNAND(struct yaffs_DeviceStruct *dev,
 /*
  * Block retiring for handling a broken block.
  */
+
 static void yaffs_RetireBlock(yaffs_Device * dev, int blockInNAND)
 {
        yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, blockInNAND);
 
        yaffs_InvalidateCheckpoint(dev);
-       
+
        yaffs_MarkBlockBad(dev, blockInNAND);
 
        bi->blockState = YAFFS_BLOCK_STATE_DEAD;
@@ -1028,7 +1028,7 @@ static void yaffs_RetireBlock(yaffs_Device * dev, int blockInNAND)
  * Functions for robustisizing TODO
  *
  */
+
 static void yaffs_HandleWriteChunkOk(yaffs_Device * dev, int chunkInNAND,
                                     const __u8 * data,
                                     const yaffs_ExtendedTags * tags)
@@ -1046,13 +1046,13 @@ void yaffs_HandleChunkError(yaffs_Device *dev, yaffs_BlockInfo *bi)
                bi->gcPrioritise = 1;
                dev->hasPendingPrioritisedGCs = 1;
                bi->chunkErrorStrikes ++;
-               
+
                if(bi->chunkErrorStrikes > 3){
                        bi->needsRetiring = 1; /* Too many stikes, so retire this */
                        T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: Block struck out" TENDSTR)));
 
                }
-               
+
        }
 }
 
@@ -1063,23 +1063,23 @@ static void yaffs_HandleWriteChunkError(yaffs_Device * dev, int chunkInNAND, int
        yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, blockInNAND);
 
        yaffs_HandleChunkError(dev,bi);
-               
-       
+
+
        if(erasedOk ) {
                /* Was an actual write failure, so mark the block for retirement  */
                bi->needsRetiring = 1;
                T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS,
                  (TSTR("**>> Block %d needs retiring" TENDSTR), blockInNAND));
 
-               
+
        }
-       
+
        /* Delete the chunk */
        yaffs_DeleteChunk(dev, chunkInNAND, 1, __LINE__);
 }
 
 
-/*---------------- Name handling functions ------------*/ 
+/*---------------- Name handling functions ------------*/
 
 static __u16 yaffs_CalcNameSum(const YCHAR * name)
 {
@@ -1120,7 +1120,7 @@ static void yaffs_SetObjectName(yaffs_Object * obj, const YCHAR * name)
  * The list is hooked together using the first pointer
  * in the tnode.
  */
+
 /* yaffs_CreateTnodes creates a bunch more tnodes and
  * adds them to the tnode free list.
  * Don't use this function directly
@@ -1138,7 +1138,7 @@ 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;
@@ -1175,7 +1175,7 @@ static int yaffs_CreateTnodes(yaffs_Device * dev, int nTnodes)
                next = (yaffs_Tnode *) &mem[(i+1) * tnodeSize];
                curr->internal[0] = next;
        }
-       
+
        curr = (yaffs_Tnode *) &mem[(nTnodes - 1) * tnodeSize];
        curr->internal[0] = dev->freeTnodes;
        dev->freeTnodes = (yaffs_Tnode *)mem;
@@ -1190,7 +1190,7 @@ static int yaffs_CreateTnodes(yaffs_Device * dev, int nTnodes)
         * NB If we can't add this to the management list it isn't fatal
         * but it just means we can't free this bunch of tnodes later.
         */
-        
+
        tnl = YMALLOC(sizeof(yaffs_TnodeList));
        if (!tnl) {
                T(YAFFS_TRACE_ERROR,
@@ -1239,11 +1239,11 @@ static yaffs_Tnode *yaffs_GetTnodeRaw(yaffs_Device * dev)
 static yaffs_Tnode *yaffs_GetTnode(yaffs_Device * dev)
 {
        yaffs_Tnode *tn = yaffs_GetTnodeRaw(dev);
-       
+
        if(tn)
                memset(tn, 0, (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8);
 
-       return tn;      
+       return tn;
 }
 
 /* FreeTnode frees up a tnode and puts it back on the free list */
@@ -1299,19 +1299,19 @@ void yaffs_PutLevel0Tnode(yaffs_Device *dev, yaffs_Tnode *tn, unsigned pos, unsi
   __u32 bitInWord;
   __u32 wordInMap;
   __u32 mask;
-  
+
   pos &= YAFFS_TNODES_LEVEL0_MASK;
   val >>= dev->chunkGroupBits;
-  
+
   bitInMap = pos * dev->tnodeWidth;
   wordInMap = bitInMap /32;
   bitInWord = bitInMap & (32 -1);
-  
+
   mask = dev->tnodeMask << bitInWord;
-  
+
   map[wordInMap] &= ~mask;
   map[wordInMap] |= (mask & (val << bitInWord));
-  
+
   if(dev->tnodeWidth > (32-bitInWord)) {
     bitInWord = (32 - bitInWord);
     wordInMap++;;
@@ -1328,24 +1328,24 @@ static __u32 yaffs_GetChunkGroupBase(yaffs_Device *dev, yaffs_Tnode *tn, unsigne
   __u32 bitInWord;
   __u32 wordInMap;
   __u32 val;
-  
+
   pos &= YAFFS_TNODES_LEVEL0_MASK;
-  
+
   bitInMap = pos * dev->tnodeWidth;
   wordInMap = bitInMap /32;
   bitInWord = bitInMap & (32 -1);
-  
+
   val = map[wordInMap] >> bitInWord;
-  
+
   if(dev->tnodeWidth > (32-bitInWord)) {
     bitInWord = (32 - bitInWord);
     wordInMap++;;
     val |= (map[wordInMap] << bitInWord);
   }
-  
+
   val &= dev->tnodeMask;
   val <<= dev->chunkGroupBits;
-  
+
   return val;
 }
 
@@ -1394,7 +1394,7 @@ static yaffs_Tnode *yaffs_FindLevel0Tnode(yaffs_Device * dev,
        while (level > 0 && tn) {
                tn = tn->
                    internal[(chunkId >>
-                              ( YAFFS_TNODES_LEVEL0_BITS + 
+                              ( YAFFS_TNODES_LEVEL0_BITS +
                                 (level - 1) *
                                 YAFFS_TNODES_INTERNAL_BITS)
                              ) &
@@ -1416,7 +1416,7 @@ static yaffs_Tnode *yaffs_FindLevel0Tnode(yaffs_Device * dev,
  *  If the tn argument is NULL, then a fresh tnode will be added otherwise the specified tn will
  *  be plugged into the ttree.
  */
+
 static yaffs_Tnode *yaffs_AddOrFindLevel0Tnode(yaffs_Device * dev,
                                               yaffs_FileStructure * fStruct,
                                               __u32 chunkId,
@@ -1453,7 +1453,7 @@ static yaffs_Tnode *yaffs_AddOrFindLevel0Tnode(yaffs_Device * dev,
        if (requiredTallness > fStruct->topLevel) {
                /* Not tall enough,gotta make the tree taller */
                for (i = fStruct->topLevel; i < requiredTallness; i++) {
-               
+
                        tn = yaffs_GetTnode(dev);
 
                        if (tn) {
@@ -1472,7 +1472,7 @@ static yaffs_Tnode *yaffs_AddOrFindLevel0Tnode(yaffs_Device * dev,
 
        l = fStruct->topLevel;
        tn = fStruct->top;
-       
+
        if(l > 0) {
                while (l > 0 && tn) {
                        x = (chunkId >>
@@ -1492,13 +1492,13 @@ static yaffs_Tnode *yaffs_AddOrFindLevel0Tnode(yaffs_Device * dev,
                                        if(tn->internal[x])
                                                yaffs_FreeTnode(dev,tn->internal[x]);
                                        tn->internal[x] = passedTn;
-                       
+
                                } else if(!tn->internal[x]) {
                                        /* Don't have one, none passed in */
                                        tn->internal[x] = yaffs_GetTnode(dev);
                                }
                        }
-               
+
                        tn = tn->internal[x];
                        l--;
                }
@@ -1539,7 +1539,7 @@ static int yaffs_FindChunkInGroup(yaffs_Device * dev, int theChunk,
 
 /* DeleteWorker scans backwards through the tnode tree and deletes all the
  * chunks and tnodes in the file
- * Returns 1 if the tree was deleted. 
+ * Returns 1 if the tree was deleted.
  * Returns 0 if it stopped early due to hitting the limit and the delete is incomplete.
  */
 
@@ -1653,7 +1653,7 @@ static void yaffs_SoftDeleteChunk(yaffs_Device * dev, int chunk)
  * of the tnode.
  * Thus, essentially this is the same as DeleteWorker except that the chunks are soft deleted.
  */
+
 static int yaffs_SoftDeleteWorker(yaffs_Object * in, yaffs_Tnode * tn,
                                  __u32 level, int chunkOffset)
 {
@@ -1694,7 +1694,7 @@ static int yaffs_SoftDeleteWorker(yaffs_Object * in, yaffs_Tnode * tn,
                                theChunk = yaffs_GetChunkGroupBase(dev,tn,i);
                                if (theChunk) {
                                        /* Note this does not find the real chunk, only the chunk group.
-                                        * We make an assumption that a chunk group is not larger than 
+                                        * We make an assumption that a chunk group is not larger than
                                         * a block.
                                         */
                                        yaffs_SoftDeleteChunk(dev, theChunk);
@@ -1796,7 +1796,7 @@ static int yaffs_PruneFileStructure(yaffs_Device * dev,
                /* Now we have a tree with all the non-zero branches NULL but the height
                 * is the same as it was.
                 * Let's see if we can trim internal tnodes to shorten the tree.
-                * We can do this if only the 0th element in the tnode is in use 
+                * We can do this if only the 0th element in the tnode is in use
                 * (ie all the non-zero are NULL)
                 */
 
@@ -1850,7 +1850,7 @@ static int yaffs_CreateFreeObjects(yaffs_Device * dev, int nObjects)
                  (TSTR("yaffs: Could not allocate more objects" TENDSTR)));
                return YAFFS_FAIL;
        }
-       
+
        /* Hook them into the free list */
        for (i = 0; i < nObjects - 1; i++) {
                newObjects[i].siblings.next =
@@ -2132,7 +2132,7 @@ yaffs_Object *yaffs_CreateNewObject(yaffs_Device * dev, int number,
        theObject = yaffs_AllocateEmptyObject(dev);
        if(!theObject)
                return NULL;
-               
+
        if(type == YAFFS_OBJECT_TYPE_FILE){
                tn = yaffs_GetTnode(dev);
                if(!tn){
@@ -2140,8 +2140,8 @@ yaffs_Object *yaffs_CreateNewObject(yaffs_Device * dev, int number,
                        return NULL;
                }
        }
-               
-       
+
+
 
        if (theObject) {
                theObject->fake = 0;
@@ -2205,7 +2205,7 @@ static yaffs_Object *yaffs_FindOrCreateObjectByNumber(yaffs_Device * dev,
        return theObject;
 
 }
-                       
+
 
 static YCHAR *yaffs_CloneString(const YCHAR * str)
 {
@@ -2227,7 +2227,7 @@ static YCHAR *yaffs_CloneString(const YCHAR * str)
  * aliasString only has meaning for a sumlink.
  * rdev only has meaning for devices (a subset of special objects)
  */
+
 static yaffs_Object *yaffs_MknodObject(yaffs_ObjectType type,
                                       yaffs_Object * parent,
                                       const YCHAR * name,
@@ -2248,7 +2248,7 @@ static yaffs_Object *yaffs_MknodObject(yaffs_ObjectType type,
        }
 
        in = yaffs_CreateNewObject(dev, -1, type);
-       
+
        if(type == YAFFS_OBJECT_TYPE_SYMLINK){
                str = yaffs_CloneString(aliasString);
                if(!str){
@@ -2256,8 +2256,8 @@ static yaffs_Object *yaffs_MknodObject(yaffs_ObjectType type,
                        return NULL;
                }
        }
-       
-       
+
+
 
        if (in) {
                in->chunkId = -1;
@@ -2298,7 +2298,7 @@ static yaffs_Object *yaffs_MknodObject(yaffs_ObjectType type,
                            equivalentObject->objectId;
                        list_add(&in->hardLinks, &equivalentObject->hardLinks);
                        break;
-               case YAFFS_OBJECT_TYPE_FILE:    
+               case YAFFS_OBJECT_TYPE_FILE:
                case YAFFS_OBJECT_TYPE_DIRECTORY:
                case YAFFS_OBJECT_TYPE_SPECIAL:
                case YAFFS_OBJECT_TYPE_UNKNOWN:
@@ -2382,7 +2382,7 @@ static int yaffs_ChangeObjectName(yaffs_Object * obj, yaffs_Object * newDir,
                    TENDSTR)));
                YBUG();
        }
-       
+
        /* TODO: Do we need this different handling for YAFFS2 and YAFFS1?? */
        if (obj->myDev->isYaffs2) {
                unlinkOp = (newDir == obj->myDev->unlinkedDir);
@@ -2395,9 +2395,9 @@ static int yaffs_ChangeObjectName(yaffs_Object * obj, yaffs_Object * newDir,
 
        existingTarget = yaffs_FindObjectByName(newDir, newName);
 
-       /* If the object is a file going into the unlinked directory, 
+       /* If the object is a file going into the unlinked directory,
         *   then it is OK to just stuff it in since duplicate names are allowed.
-        *   else only proceed if the new name does not exist and if we're putting 
+        *   else only proceed if the new name does not exist and if we're putting
         *   it into a directory.
         */
        if ((unlinkOp ||
@@ -2461,7 +2461,7 @@ int yaffs_RenameObject(yaffs_Object * oldDir, const YCHAR * oldName,
                        /* There is a target that is a non-empty directory, so we fail */
                        return YAFFS_FAIL;      /* EEXIST or ENOTEMPTY */
                } else if (existingTarget && existingTarget != obj) {
-                       /* Nuke the target first, using shadowing, 
+                       /* Nuke the target first, using shadowing,
                         * but only if it isn't the same object
                         */
                        yaffs_ChangeObjectName(obj, newDir, newName, force,
@@ -2479,10 +2479,10 @@ int yaffs_RenameObject(yaffs_Object * oldDir, const YCHAR * oldName,
 static int yaffs_InitialiseBlocks(yaffs_Device * dev)
 {
        int nBlocks = dev->internalEndBlock - dev->internalStartBlock + 1;
-       
+
        dev->blockInfo = NULL;
        dev->chunkBits = NULL;
-       
+
        dev->allocationBlock = -1;      /* force it to get a new one */
 
        /* If the first allocation strategy fails, thry the alternate one */
@@ -2493,9 +2493,9 @@ static int yaffs_InitialiseBlocks(yaffs_Device * dev)
        }
        else
                dev->blockInfoAlt = 0;
-               
+
        if(dev->blockInfo){
-       
+
                /* Set up dynamic blockinfo stuff. */
                dev->chunkBitmapStride = (dev->nChunksPerBlock + 7) / 8; /* round up bytes */
                dev->chunkBits = YMALLOC(dev->chunkBitmapStride * nBlocks);
@@ -2506,7 +2506,7 @@ static int yaffs_InitialiseBlocks(yaffs_Device * dev)
                else
                        dev->chunkBitsAlt = 0;
        }
-       
+
        if (dev->blockInfo && dev->chunkBits) {
                memset(dev->blockInfo, 0, nBlocks * sizeof(yaffs_BlockInfo));
                memset(dev->chunkBits, 0, dev->chunkBitmapStride * nBlocks);
@@ -2527,7 +2527,7 @@ static void yaffs_DeinitialiseBlocks(yaffs_Device * dev)
        dev->blockInfoAlt = 0;
 
        dev->blockInfo = NULL;
-       
+
        if(dev->chunkBitsAlt && dev->chunkBits)
                YFREE_ALT(dev->chunkBits);
        else if(dev->chunkBits)
@@ -2591,14 +2591,14 @@ static int yaffs_FindBlockForGarbageCollection(yaffs_Device * dev,
        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++){
 
                        bi = yaffs_GetBlockInfo(dev, i);
                        //yaffs_VerifyBlock(dev,bi,i);
-                       
+
                        if(bi->gcPrioritise) {
                                pendingPrioritisedExist = 1;
                                if(bi->blockState == YAFFS_BLOCK_STATE_FULL &&
@@ -2610,7 +2610,7 @@ static int yaffs_FindBlockForGarbageCollection(yaffs_Device * dev,
                                }
                        }
                }
-               
+
                if(!pendingPrioritisedExist) /* None found, so we can clear this */
                        dev->hasPendingPrioritisedGCs = 0;
        }
@@ -2662,7 +2662,7 @@ static int yaffs_FindBlockForGarbageCollection(yaffs_Device * dev,
                        dirtiest = b;
                        pagesInUse = 0;
                }
-               else 
+               else
 #endif
 
                if (bi->blockState == YAFFS_BLOCK_STATE_FULL &&
@@ -2699,11 +2699,11 @@ static void yaffs_BlockBecameDirty(yaffs_Device * dev, int blockNo)
        /* If the block is still healthy erase it and mark as clean.
         * If the block has had a data failure, then retire it.
         */
-        
+
        T(YAFFS_TRACE_GC | YAFFS_TRACE_ERASE,
                (TSTR("yaffs_BlockBecameDirty block %d state %d %s"TENDSTR),
                blockNo, bi->blockState, (bi->needsRetiring) ? "needs retiring" : ""));
-               
+
        bi->blockState = YAFFS_BLOCK_STATE_DIRTY;
 
        if (!bi->needsRetiring) {
@@ -2716,7 +2716,7 @@ static void yaffs_BlockBecameDirty(yaffs_Device * dev, int blockNo)
                }
        }
 
-       if (erasedOk && 
+       if (erasedOk &&
            ((yaffs_traceMask & YAFFS_TRACE_ERASE) || !yaffs_SkipVerification(dev))) {
                int i;
                for (i = 0; i < dev->nChunksPerBlock; i++) {
@@ -2767,7 +2767,7 @@ static int yaffs_FindBlockForAllocation(yaffs_Device * dev)
 
                return -1;
        }
-       
+
        /* Find an empty block. */
 
        for (i = dev->internalStartBlock; i <= dev->internalEndBlock; i++) {
@@ -2808,13 +2808,13 @@ static int yaffs_CheckSpaceForAllocation(yaffs_Device * dev)
        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);
 }
 
@@ -2861,10 +2861,10 @@ static int yaffs_AllocateChunk(yaffs_Device * dev, int useReserve, yaffs_BlockIn
 
                if(blockUsedPtr)
                        *blockUsedPtr = bi;
-                       
+
                return retVal;
        }
-       
+
        T(YAFFS_TRACE_ERROR,
          (TSTR("!!!!!!!!! Allocator out !!!!!!!!!!!!!!!!!" TENDSTR)));
 
@@ -2907,7 +2907,7 @@ static int yaffs_GarbageCollectBlock(yaffs_Device * dev, int block)
        yaffs_Object *object;
 
        isCheckpointBlock = (bi->blockState == YAFFS_BLOCK_STATE_CHECKPOINT);
-       
+
        bi->blockState = YAFFS_BLOCK_STATE_COLLECTING;
 
        T(YAFFS_TRACE_TRACING,
@@ -2935,7 +2935,7 @@ static int yaffs_GarbageCollectBlock(yaffs_Device * dev, int block)
        } else {
 
                __u8 *buffer = yaffs_GetTempBuffer(dev, __LINE__);
-               
+
                yaffs_VerifyBlock(dev,bi,block);
 
                for (chunkInBlock = 0, oldChunk = block * dev->nChunksPerBlock;
@@ -2962,7 +2962,7 @@ static int yaffs_GarbageCollectBlock(yaffs_Device * dev, int block)
                                   ("Collecting page %d, %d %d %d " TENDSTR),
                                   chunkInBlock, tags.objectId, tags.chunkId,
                                   tags.byteCount));
-                                  
+
                                if(object && !yaffs_SkipVerification(dev)){
                                        if(tags.chunkId == 0)
                                                matchingChunk = object->chunkId;
@@ -2970,12 +2970,12 @@ static int yaffs_GarbageCollectBlock(yaffs_Device * dev, int block)
                                                matchingChunk = oldChunk; /* Defeat the test */
                                        else
                                                matchingChunk = yaffs_FindChunkInFile(object,tags.chunkId,NULL);
-                                       
+
                                        if(oldChunk != matchingChunk)
                                                T(YAFFS_TRACE_ERROR,
                                                  (TSTR("gc: page in gc mismatch: %d %d %d %d"TENDSTR),
                                                  oldChunk,matchingChunk,tags.objectId, tags.chunkId));
-                                               
+
                                }
 
                                if (!object) {
@@ -2990,7 +2990,7 @@ static int yaffs_GarbageCollectBlock(yaffs_Device * dev, int block)
                                    && tags.chunkId != 0) {
                                        /* Data chunk in a deleted file, throw it away
                                         * It's a soft deleted data chunk,
-                                        * No need to copy this, just forget about it and 
+                                        * No need to copy this, just forget about it and
                                         * fix up the object.
                                         */
 
@@ -3040,7 +3040,7 @@ static int yaffs_GarbageCollectBlock(yaffs_Device * dev, int block)
                                                oh->shadowsObject = -1;
                                                tags.extraShadows = 0;
                                                tags.extraIsShrinkHeader = 0;
-                                               
+
                                                yaffs_VerifyObjectHeader(object,oh,&tags,1);
                                        }
 
@@ -3099,7 +3099,7 @@ static int yaffs_GarbageCollectBlock(yaffs_Device * dev, int block)
        }
 
        yaffs_VerifyCollectedBlock(dev,bi,block);
-         
+
        if (chunksBefore >= (chunksAfter = yaffs_GetErasedChunks(dev))) {
                T(YAFFS_TRACE_GC,
                  (TSTR
@@ -3127,21 +3127,21 @@ static int yaffs_CheckGarbageCollection(yaffs_Device * dev)
        int aggressive;
        int gcOk = YAFFS_OK;
        int maxTries = 0;
-       
+
        int checkpointBlockAdjust;
 
        if (dev->isDoingGC) {
                /* 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.
         */
 
        do {
                maxTries++;
-               
+
                checkpointBlockAdjust = (dev->nCheckpointReservedBlocks - dev->blocksInCheckpoint);
                if(checkpointBlockAdjust < 0)
                        checkpointBlockAdjust = 0;
@@ -3326,11 +3326,11 @@ static int yaffs_CheckFileSanity(yaffs_Object * in)
 static int yaffs_PutChunkIntoFile(yaffs_Object * in, int chunkInInode,
                                  int chunkInNAND, int inScan)
 {
-       /* NB inScan is zero unless scanning. 
-        * For forward scanning, inScan is > 0; 
+       /* NB inScan is zero unless scanning.
+        * For forward scanning, inScan is > 0;
         * for backward scanning inScan is < 0
         */
-        
+
        yaffs_Tnode *tn;
        yaffs_Device *dev = in->myDev;
        int existingChunk;
@@ -3354,7 +3354,7 @@ static int yaffs_PutChunkIntoFile(yaffs_Object * in, int chunkInInode,
                return YAFFS_OK;
        }
 
-       tn = yaffs_AddOrFindLevel0Tnode(dev, 
+       tn = yaffs_AddOrFindLevel0Tnode(dev,
                                        &in->variant.fileVariant,
                                        chunkInInode,
                                        NULL);
@@ -3366,7 +3366,7 @@ static int yaffs_PutChunkIntoFile(yaffs_Object * in, int chunkInInode,
 
        if (inScan != 0) {
                /* If we're scanning then we need to test for duplicates
-                * NB This does not need to be efficient since it should only ever 
+                * NB This does not need to be efficient since it should only ever
                 * happen when the power fails during a write, then only one
                 * chunk should ever be affected.
                 *
@@ -3407,7 +3407,7 @@ static int yaffs_PutChunkIntoFile(yaffs_Object * in, int chunkInInode,
 
                        }
 
-                       /* NB The deleted flags should be false, otherwise the chunks will 
+                       /* NB The deleted flags should be false, otherwise the chunks will
                         * not be loaded during a scan
                         */
 
@@ -3418,7 +3418,7 @@ static int yaffs_PutChunkIntoFile(yaffs_Object * in, int chunkInInode,
                            (in->myDev->isYaffs2 ||
                             existingChunk <= 0 ||
                             ((existingSerial + 1) & 3) == newSerial)) {
-                               /* Forward scanning.                            
+                               /* Forward scanning.
                                 * Use new
                                 * Delete the old one and drop through to update the tnode
                                 */
@@ -3459,7 +3459,7 @@ static int yaffs_ReadChunkDataFromObject(yaffs_Object * in, int chunkInInode,
                  (TSTR("Chunk %d not found zero instead" TENDSTR),
                   chunkInNAND));
                /* get sane (zero) data if you read a hole */
-               memset(buffer, 0, in->myDev->nDataBytesPerChunk);       
+               memset(buffer, 0, in->myDev->nDataBytesPerChunk);
                return 0;
        }
 
@@ -3474,7 +3474,7 @@ void yaffs_DeleteChunk(yaffs_Device * dev, int chunkId, int markNAND, int lyn)
 
        if (chunkId <= 0)
                return;
-               
+
 
        dev->nDeletions++;
        block = chunkId / dev->nChunksPerBlock;
@@ -3602,7 +3602,7 @@ int yaffs_UpdateObjectHeader(yaffs_Object * in, const YCHAR * name, int force,
        YCHAR oldName[YAFFS_MAX_NAME_LENGTH + 1];
 
        yaffs_ObjectHeader *oh = NULL;
-       
+
        yaffs_strcpy(oldName,"silly old name");
 
        if (!in->fake || force) {
@@ -3618,9 +3618,9 @@ int yaffs_UpdateObjectHeader(yaffs_Object * in, const YCHAR * name, int force,
                if (prevChunkId >= 0) {
                        result = yaffs_ReadChunkWithTagsFromNAND(dev, prevChunkId,
                                                        buffer, &oldTags);
-                       
+
                        yaffs_VerifyObjectHeader(in,oh,&oldTags,0);
-                                                                               
+
                        memcpy(oldName, oh->name, sizeof(oh->name));
                }
 
@@ -3748,11 +3748,11 @@ int yaffs_UpdateObjectHeader(yaffs_Object * in, const YCHAR * name, int force,
 
 /*------------------------ Short Operations Cache ----------------------------------------
  *   In many situations where there is no high level buffering (eg WinCE) a lot of
- *   reads might be short sequential reads, and a lot of writes may be short 
+ *   reads might be short sequential reads, and a lot of writes may be short
  *   sequential writes. eg. scanning/writing a jpeg file.
- *   In these cases, a short read/write cache can provide a huge perfomance benefit 
+ *   In these cases, a short read/write cache can provide a huge perfomance benefit
  *   with dumb-as-a-rock code.
- *   In Linux, the page cache provides read buffering aand the short op cache provides write 
+ *   In Linux, the page cache provides read buffering aand the short op cache provides write
  *   buffering.
  *
  *   There are a limited number (~10) of cache chunks per device so that we don't
@@ -3765,14 +3765,14 @@ static int yaffs_ObjectHasCachedWriteData(yaffs_Object *obj)
        int i;
        yaffs_ChunkCache *cache;
        int nCaches = obj->myDev->nShortOpCaches;
-       
+
        for(i = 0; i < nCaches; i++){
                cache = &dev->srCache[i];
                if (cache->object == obj &&
                    cache->dirty)
                        return 1;
        }
-       
+
        return 0;
 }
 
@@ -3838,7 +3838,7 @@ void yaffs_FlushEntireDeviceCache(yaffs_Device *dev)
        yaffs_Object *obj;
        int nCaches = dev->nShortOpCaches;
        int i;
-       
+
        /* Find a dirty object in the cache and flush it...
         * until there are no further dirty objects.
         */
@@ -3848,18 +3848,18 @@ void yaffs_FlushEntireDeviceCache(yaffs_Device *dev)
                        if (dev->srCache[i].object &&
                            dev->srCache[i].dirty)
                                obj = dev->srCache[i].object;
-                           
+
                }
                if(obj)
                        yaffs_FlushFilesChunkCache(obj);
-                       
+
        } while(obj);
-       
+
 }
 
 
 /* Grab us a cache chunk for use.
- * First look for an empty one. 
+ * First look for an empty one.
  * Then look for the least recently used non-dirty one.
  * Then look for the least recently used dirty one...., flush and look again.
  */
@@ -3871,7 +3871,7 @@ static yaffs_ChunkCache *yaffs_GrabChunkCacheWorker(yaffs_Device * dev)
 
        if (dev->nShortOpCaches > 0) {
                for (i = 0; i < dev->nShortOpCaches; i++) {
-                       if (!dev->srCache[i].object) 
+                       if (!dev->srCache[i].object)
                                return &dev->srCache[i];
                }
 
@@ -4032,14 +4032,14 @@ static void yaffs_InvalidateWholeChunkCache(yaffs_Object * in)
 static int yaffs_WriteCheckpointValidityMarker(yaffs_Device *dev,int head)
 {
        yaffs_CheckpointValidity cp;
-       
+
        memset(&cp,0,sizeof(cp));
-       
+
        cp.structType = sizeof(cp);
        cp.magic = YAFFS_MAGIC;
        cp.version = YAFFS_CHECKPOINT_VERSION;
        cp.head = (head) ? 1 : 0;
-       
+
        return (yaffs_CheckpointWrite(dev,&cp,sizeof(cp)) == sizeof(cp))?
                1 : 0;
 }
@@ -4048,9 +4048,9 @@ static int yaffs_ReadCheckpointValidityMarker(yaffs_Device *dev, int head)
 {
        yaffs_CheckpointValidity cp;
        int ok;
-       
+
        ok = (yaffs_CheckpointRead(dev,&cp,sizeof(cp)) == sizeof(cp));
-       
+
        if(ok)
                ok = (cp.structType == sizeof(cp)) &&
                     (cp.magic == YAFFS_MAGIC) &&
@@ -4059,20 +4059,20 @@ static int yaffs_ReadCheckpointValidityMarker(yaffs_Device *dev, int head)
        return ok ? 1 : 0;
 }
 
-static void yaffs_DeviceToCheckpointDevice(yaffs_CheckpointDevice *cp, 
+static void yaffs_DeviceToCheckpointDevice(yaffs_CheckpointDevice *cp,
                                           yaffs_Device *dev)
 {
        cp->nErasedBlocks = dev->nErasedBlocks;
        cp->allocationBlock = dev->allocationBlock;
        cp->allocationPage = dev->allocationPage;
        cp->nFreeChunks = dev->nFreeChunks;
-       
+
        cp->nDeletedFiles = dev->nDeletedFiles;
        cp->nUnlinkedFiles = dev->nUnlinkedFiles;
        cp->nBackgroundDeletions = dev->nBackgroundDeletions;
        cp->sequenceNumber = dev->sequenceNumber;
        cp->oldestDirtySequence = dev->oldestDirtySequence;
-       
+
 }
 
 static void yaffs_CheckpointDeviceToDevice(yaffs_Device *dev,
@@ -4082,7 +4082,7 @@ static void yaffs_CheckpointDeviceToDevice(yaffs_Device *dev,
        dev->allocationBlock = cp->allocationBlock;
        dev->allocationPage = cp->allocationPage;
        dev->nFreeChunks = cp->nFreeChunks;
-       
+
        dev->nDeletedFiles = cp->nDeletedFiles;
        dev->nUnlinkedFiles = cp->nUnlinkedFiles;
        dev->nBackgroundDeletions = cp->nBackgroundDeletions;
@@ -4098,20 +4098,20 @@ static int yaffs_WriteCheckpointDevice(yaffs_Device *dev)
        __u32 nBlocks = (dev->internalEndBlock - dev->internalStartBlock + 1);
 
        int ok;
-               
+
        /* Write device runtime values*/
        yaffs_DeviceToCheckpointDevice(&cp,dev);
        cp.structType = sizeof(cp);
-       
+
        ok = (yaffs_CheckpointWrite(dev,&cp,sizeof(cp)) == sizeof(cp));
-       
+
        /* Write block info */
        if(ok) {
                nBytes = nBlocks * sizeof(yaffs_BlockInfo);
                ok = (yaffs_CheckpointWrite(dev,dev->blockInfo,nBytes) == nBytes);
        }
-               
-       /* Write chunk bits */          
+
+       /* Write chunk bits */
        if(ok) {
                nBytes = nBlocks * dev->chunkBitmapStride;
                ok = (yaffs_CheckpointWrite(dev,dev->chunkBits,nBytes) == nBytes);
@@ -4126,28 +4126,28 @@ static int yaffs_ReadCheckpointDevice(yaffs_Device *dev)
        __u32 nBytes;
        __u32 nBlocks = (dev->internalEndBlock - dev->internalStartBlock + 1);
 
-       int ok; 
-       
+       int ok;
+
        ok = (yaffs_CheckpointRead(dev,&cp,sizeof(cp)) == sizeof(cp));
        if(!ok)
                return 0;
-               
+
        if(cp.structType != sizeof(cp))
                return 0;
-               
-       
+
+
        yaffs_CheckpointDeviceToDevice(dev,&cp);
-       
+
        nBytes = nBlocks * sizeof(yaffs_BlockInfo);
-       
+
        ok = (yaffs_CheckpointRead(dev,dev->blockInfo,nBytes) == nBytes);
-       
+
        if(!ok)
                return 0;
        nBytes = nBlocks * dev->chunkBitmapStride;
-       
+
        ok = (yaffs_CheckpointRead(dev,dev->chunkBits,nBytes) == nBytes);
-       
+
        return ok ? 1 : 0;
 }
 
@@ -4158,7 +4158,7 @@ static void yaffs_ObjectToCheckpointObject(yaffs_CheckpointObject *cp,
        cp->objectId = obj->objectId;
        cp->parentId = (obj->parent) ? obj->parent->objectId : 0;
        cp->chunkId = obj->chunkId;
-       cp->variantType = obj->variantType;                     
+       cp->variantType = obj->variantType;
        cp->deleted = obj->deleted;
        cp->softDeleted = obj->softDeleted;
        cp->unlinked = obj->unlinked;
@@ -4167,7 +4167,7 @@ static void yaffs_ObjectToCheckpointObject(yaffs_CheckpointObject *cp,
        cp->unlinkAllowed = obj->unlinkAllowed;
        cp->serial = obj->serial;
        cp->nDataChunks = obj->nDataChunks;
-       
+
        if(obj->variantType == YAFFS_OBJECT_TYPE_FILE)
                cp->fileSizeOrEquivalentObjectId = obj->variant.fileVariant.fileSize;
        else if(obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK)
@@ -4178,9 +4178,9 @@ static void yaffs_CheckpointObjectToObject( yaffs_Object *obj,yaffs_CheckpointOb
 {
 
        yaffs_Object *parent;
-       
+
        obj->objectId = cp->objectId;
-       
+
        if(cp->parentId)
                parent = yaffs_FindOrCreateObjectByNumber(
                                        obj->myDev,
@@ -4188,12 +4188,12 @@ static void yaffs_CheckpointObjectToObject( yaffs_Object *obj,yaffs_CheckpointOb
                                        YAFFS_OBJECT_TYPE_DIRECTORY);
        else
                parent = NULL;
-               
+
        if(parent)
                yaffs_AddObjectToDirectory(parent, obj);
-               
+
        obj->chunkId = cp->chunkId;
-       obj->variantType = cp->variantType;                     
+       obj->variantType = cp->variantType;
        obj->deleted = cp->deleted;
        obj->softDeleted = cp->softDeleted;
        obj->unlinked = cp->unlinked;
@@ -4202,12 +4202,12 @@ static void yaffs_CheckpointObjectToObject( yaffs_Object *obj,yaffs_CheckpointOb
        obj->unlinkAllowed = cp->unlinkAllowed;
        obj->serial = cp->serial;
        obj->nDataChunks = cp->nDataChunks;
-       
+
        if(obj->variantType == YAFFS_OBJECT_TYPE_FILE)
                obj->variant.fileVariant.fileSize = cp->fileSizeOrEquivalentObjectId;
        else if(obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK)
                obj->variant.hardLinkVariant.equivalentObjectId = cp->fileSizeOrEquivalentObjectId;
-               
+
        if(obj->objectId >= YAFFS_NOBJECT_BUCKETS)
                obj->lazyLoaded = 1;
 }
@@ -4250,17 +4250,17 @@ static int yaffs_WriteCheckpointTnodes(yaffs_Object *obj)
 {
        __u32 endMarker = ~0;
        int ok = 1;
-       
+
        if(obj->variantType == YAFFS_OBJECT_TYPE_FILE){
                ok = yaffs_CheckpointTnodeWorker(obj,
                                            obj->variant.fileVariant.top,
                                            obj->variant.fileVariant.topLevel,
                                            0);
                if(ok)
-                       ok = (yaffs_CheckpointWrite(obj->myDev,&endMarker,sizeof(endMarker)) == 
+                       ok = (yaffs_CheckpointWrite(obj->myDev,&endMarker,sizeof(endMarker)) ==
                                sizeof(endMarker));
        }
-       
+
        return ok ? 1 : 0;
 }
 
@@ -4272,14 +4272,14 @@ static int yaffs_ReadCheckpointTnodes(yaffs_Object *obj)
        yaffs_FileStructure *fileStructPtr = &obj->variant.fileVariant;
        yaffs_Tnode *tn;
        int nread = 0;
-       
+
        ok = (yaffs_CheckpointRead(dev,&baseChunk,sizeof(baseChunk)) == sizeof(baseChunk));
-       
+
        while(ok && (~baseChunk)){
                nread++;
                /* Read level 0 tnode */
-               
-               
+
+
                /* printf("read  tnode at %d\n",baseChunk); */
                tn = yaffs_GetTnodeRaw(dev);
                if(tn)
@@ -4287,27 +4287,27 @@ static int yaffs_ReadCheckpointTnodes(yaffs_Object *obj)
                              (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8);
                else
                        ok = 0;
-                       
+
                if(tn && ok){
                        ok = yaffs_AddOrFindLevel0Tnode(dev,
                                                        fileStructPtr,
                                                        baseChunk,
                                                        tn) ? 1 : 0;
-                                                       
+
                }
-                       
+
                if(ok)
                        ok = (yaffs_CheckpointRead(dev,&baseChunk,sizeof(baseChunk)) == sizeof(baseChunk));
-               
+
        }
 
        T(YAFFS_TRACE_CHECKPOINT,(
                TSTR("Checkpoint read tnodes %d records, last %d. ok %d" TENDSTR),
                nread,baseChunk,ok));
 
-       return ok ? 1 : 0;      
+       return ok ? 1 : 0;
 }
+
 
 static int yaffs_WriteCheckpointObjects(yaffs_Device *dev)
 {
@@ -4317,11 +4317,11 @@ static int yaffs_WriteCheckpointObjects(yaffs_Device *dev)
        int ok = 1;
        struct list_head *lh;
 
-       
+
        /* Iterate through the objects in each hash entry,
         * dumping them to the checkpointing stream.
         */
-        
+
         for(i = 0; ok &&  i <  YAFFS_NOBJECT_BUCKETS; i++){
                list_for_each(lh, &dev->objectBucket[i].list) {
                        if (lh) {
@@ -4333,9 +4333,9 @@ static int yaffs_WriteCheckpointObjects(yaffs_Device *dev)
                                        T(YAFFS_TRACE_CHECKPOINT,(
                                                TSTR("Checkpoint write object %d parent %d type %d chunk %d obj addr %x" TENDSTR),
                                                cp.objectId,cp.parentId,cp.variantType,cp.chunkId,(unsigned) obj));
-                                               
+
                                        ok = (yaffs_CheckpointWrite(dev,&cp,sizeof(cp)) == sizeof(cp));
-                                       
+
                                        if(ok && obj->variantType == YAFFS_OBJECT_TYPE_FILE){
                                                ok = yaffs_WriteCheckpointTnodes(obj);
                                        }
@@ -4343,14 +4343,14 @@ static int yaffs_WriteCheckpointObjects(yaffs_Device *dev)
                        }
                }
         }
-        
+
         /* Dump end of list */
        memset(&cp,0xFF,sizeof(yaffs_CheckpointObject));
        cp.structType = sizeof(cp);
-       
+
        if(ok)
                ok = (yaffs_CheckpointWrite(dev,&cp,sizeof(cp)) == sizeof(cp));
-               
+
        return ok ? 1 : 0;
 }
 
@@ -4361,7 +4361,7 @@ static int yaffs_ReadCheckpointObjects(yaffs_Device *dev)
        int ok = 1;
        int done = 0;
        yaffs_Object *hardList = NULL;
-       
+
        while(ok && !done) {
                ok = (yaffs_CheckpointRead(dev,&cp,sizeof(cp)) == sizeof(cp));
                if(cp.structType != sizeof(cp)) {
@@ -4369,10 +4369,10 @@ static int yaffs_ReadCheckpointObjects(yaffs_Device *dev)
                                cp.structType,sizeof(cp),ok));
                        ok = 0;
                }
-                       
+
                T(YAFFS_TRACE_CHECKPOINT,(TSTR("Checkpoint read object %d parent %d type %d chunk %d " TENDSTR),
                        cp.objectId,cp.parentId,cp.variantType,cp.chunkId));
-                       
+
                if(ok && cp.objectId == ~0)
                        done = 1;
                else if(ok){
@@ -4387,14 +4387,14 @@ static int yaffs_ReadCheckpointObjects(yaffs_Device *dev)
                                                    hardList;
                                        hardList = obj;
                                }
-                          
+
                        }
                }
        }
-       
+
        if(ok)
                yaffs_HardlinkFixup(dev,hardList);
-       
+
        return ok ? 1 : 0;
 }
 
@@ -4402,14 +4402,14 @@ static int yaffs_WriteCheckpointSum(yaffs_Device *dev)
 {
        __u32 checkpointSum;
        int ok;
-       
+
        yaffs_GetCheckpointSum(dev,&checkpointSum);
-       
+
        ok = (yaffs_CheckpointWrite(dev,&checkpointSum,sizeof(checkpointSum)) == sizeof(checkpointSum));
-       
+
        if(!ok)
                return 0;
-       
+
        return 1;
 }
 
@@ -4418,17 +4418,17 @@ static int yaffs_ReadCheckpointSum(yaffs_Device *dev)
        __u32 checkpointSum0;
        __u32 checkpointSum1;
        int ok;
-       
+
        yaffs_GetCheckpointSum(dev,&checkpointSum0);
-       
+
        ok = (yaffs_CheckpointRead(dev,&checkpointSum1,sizeof(checkpointSum1)) == sizeof(checkpointSum1));
-       
+
        if(!ok)
                return 0;
-               
+
        if(checkpointSum0 != checkpointSum1)
                return 0;
-       
+
        return 1;
 }
 
@@ -4437,15 +4437,15 @@ static int yaffs_WriteCheckpointData(yaffs_Device *dev)
 {
 
        int ok = 1;
-       
+
        if(dev->skipCheckpointWrite || !dev->isYaffs2){
                T(YAFFS_TRACE_CHECKPOINT,(TSTR("skipping checkpoint write" TENDSTR)));
                ok = 0;
        }
-               
+
        if(ok)
                ok = yaffs_CheckpointOpen(dev,1);
-       
+
        if(ok){
                T(YAFFS_TRACE_CHECKPOINT,(TSTR("write checkpoint validity" TENDSTR)));
                ok = yaffs_WriteCheckpointValidityMarker(dev,1);
@@ -4462,18 +4462,18 @@ static int yaffs_WriteCheckpointData(yaffs_Device *dev)
                T(YAFFS_TRACE_CHECKPOINT,(TSTR("write checkpoint validity" TENDSTR)));
                ok = yaffs_WriteCheckpointValidityMarker(dev,0);
        }
-       
+
        if(ok){
                ok = yaffs_WriteCheckpointSum(dev);
        }
-       
-       
+
+
        if(!yaffs_CheckpointClose(dev))
                 ok = 0;
-                
+
        if(ok)
                dev->isCheckpointed = 1;
-        else 
+        else
                dev->isCheckpointed = 0;
 
        return dev->isCheckpointed;
@@ -4482,17 +4482,17 @@ static int yaffs_WriteCheckpointData(yaffs_Device *dev)
 static int yaffs_ReadCheckpointData(yaffs_Device *dev)
 {
        int ok = 1;
-       
+
        if(dev->skipCheckpointRead || !dev->isYaffs2){
                T(YAFFS_TRACE_CHECKPOINT,(TSTR("skipping checkpoint read" TENDSTR)));
                ok = 0;
        }
-       
+
        if(ok)
                ok = yaffs_CheckpointOpen(dev,0); /* open for read */
-       
+
        if(ok){
-               T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint validity" TENDSTR)));   
+               T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint validity" TENDSTR)));
                ok = yaffs_ReadCheckpointValidityMarker(dev,1);
        }
        if(ok){
@@ -4500,14 +4500,14 @@ static int yaffs_ReadCheckpointData(yaffs_Device *dev)
                ok = yaffs_ReadCheckpointDevice(dev);
        }
        if(ok){
-               T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint objects" TENDSTR)));    
+               T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint objects" TENDSTR)));
                ok = yaffs_ReadCheckpointObjects(dev);
        }
        if(ok){
                T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint validity" TENDSTR)));
                ok = yaffs_ReadCheckpointValidityMarker(dev,0);
        }
-       
+
        if(ok){
                ok = yaffs_ReadCheckpointSum(dev);
                T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint checksum %d" TENDSTR),ok));
@@ -4518,7 +4518,7 @@ static int yaffs_ReadCheckpointData(yaffs_Device *dev)
 
        if(ok)
                dev->isCheckpointed = 1;
-        else 
+        else
                dev->isCheckpointed = 0;
 
        return ok ? 1 : 0;
@@ -4527,7 +4527,7 @@ static int yaffs_ReadCheckpointData(yaffs_Device *dev)
 
 static void yaffs_InvalidateCheckpoint(yaffs_Device *dev)
 {
-       if(dev->isCheckpointed || 
+       if(dev->isCheckpointed ||
           dev->blocksInCheckpoint > 0){
                dev->isCheckpointed = 0;
                yaffs_CheckpointInvalidateStream(dev);
@@ -4550,7 +4550,7 @@ int yaffs_CheckpointSave(yaffs_Device *dev)
                yaffs_InvalidateCheckpoint(dev);
                yaffs_WriteCheckpointData(dev);
        }
-       
+
        T(YAFFS_TRACE_ALWAYS,(TSTR("save exit: isCheckpointed %d"TENDSTR),dev->isCheckpointed));
 
        return dev->isCheckpointed;
@@ -4560,7 +4560,7 @@ int yaffs_CheckpointRestore(yaffs_Device *dev)
 {
        int retval;
        T(YAFFS_TRACE_CHECKPOINT,(TSTR("restore entry: isCheckpointed %d"TENDSTR),dev->isCheckpointed));
-               
+
        retval = yaffs_ReadCheckpointData(dev);
 
        if(dev->isCheckpointed){
@@ -4570,7 +4570,7 @@ int yaffs_CheckpointRestore(yaffs_Device *dev)
        }
 
        T(YAFFS_TRACE_CHECKPOINT,(TSTR("restore exit: isCheckpointed %d"TENDSTR),dev->isCheckpointed));
-       
+
        return retval;
 }
 
@@ -4606,7 +4606,7 @@ int yaffs_ReadDataFromFile(yaffs_Object * in, __u8 * buffer, loff_t offset,
                chunk++;
 
                /* OK now check for the curveball where the start and end are in
-                * the same chunk.      
+                * the same chunk.
                 */
                if ((start + n) < dev->nDataBytesPerChunk) {
                        nToCopy = n;
@@ -4763,7 +4763,7 @@ int yaffs_WriteDataToFile(yaffs_Object * in, const __u8 * buffer, loff_t offset,
                                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)) {
@@ -4776,12 +4776,12 @@ int yaffs_WriteDataToFile(yaffs_Object * in, const __u8 * buffer, loff_t offset,
                                                                      cache->
                                                                      data);
                                }
-                               else if(cache && 
+                               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;
                                }
 
@@ -4945,7 +4945,7 @@ int yaffs_ResizeFile(yaffs_Object * in, loff_t newSize)
        int oldFileSize = in->variant.fileVariant.fileSize;
        int newSizeOfPartialChunk;
        int newFullChunks;
-       
+
        yaffs_Device *dev = in->myDev;
 
        yaffs_AddrToChunk(dev, newSize, &newFullChunks, &newSizeOfPartialChunk);
@@ -4969,7 +4969,7 @@ int yaffs_ResizeFile(yaffs_Object * in, loff_t newSize)
 
                if (newSizeOfPartialChunk != 0) {
                        int lastChunk = 1 + newFullChunks;
-                       
+
                        __u8 *localBuffer = yaffs_GetTempBuffer(dev, __LINE__);
 
                        /* Got to read and rewrite the last chunk with its new size and zero pad */
@@ -4993,8 +4993,8 @@ int yaffs_ResizeFile(yaffs_Object * in, loff_t newSize)
                in->variant.fileVariant.fileSize = newSize;
        }
 
-               
-       
+
+
        /* Write a new object header.
         * show we've shrunk the file, if need be
         * Do this only if the file is not in the deleted directories.
@@ -5313,7 +5313,7 @@ static void yaffs_HardlinkFixup(yaffs_Device *dev, yaffs_Object *hardList)
 {
        yaffs_Object *hl;
        yaffs_Object *in;
-       
+
        while (hardList) {
                hl = hardList;
                hardList = (yaffs_Object *) (hardList->hardLinks.next);
@@ -5376,9 +5376,9 @@ static int yaffs_Scan(yaffs_Device * dev)
        yaffs_Object *in;
        yaffs_Object *parent;
        int nBlocks = dev->internalEndBlock - dev->internalStartBlock + 1;
-       
+
        int alloc_failed = 0;
-       
+
 
        __u8 *chunkData;
 
@@ -5389,9 +5389,9 @@ static int yaffs_Scan(yaffs_Device * dev)
                  (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));
@@ -5520,7 +5520,7 @@ static int yaffs_Scan(yaffs_Device * dev)
                                /*T((" %d %d deleted\n",blk,c)); */
                        } else if (!tags.chunkUsed) {
                                /* An unassigned chunk in the block
-                                * This means that either the block is empty or 
+                                * This means that either the block is empty or
                                 * this is the one being allocated from
                                 */
 
@@ -5537,9 +5537,9 @@ static int yaffs_Scan(yaffs_Device * dev)
                                        state = YAFFS_BLOCK_STATE_ALLOCATING;
                                        dev->allocationBlock = blk;
                                        dev->allocationPage = c;
-                                       dev->allocationBlockFinder = blk;       
+                                       dev->allocationBlockFinder = blk;
                                        /* Set it to here to encourage the allocator to go forth from here. */
-                                       
+
                                        /* Yaffs2 sanity check:
                                         * This should be the one with the highest sequence number
                                         */
@@ -5569,7 +5569,7 @@ static int yaffs_Scan(yaffs_Device * dev)
                                /* PutChunkIntoFile checks for a clash (two data chunks with
                                 * the same chunkId).
                                 */
-                                
+
                                if(!in)
                                        alloc_failed = 1;
 
@@ -5577,11 +5577,11 @@ static int yaffs_Scan(yaffs_Device * dev)
                                        if(!yaffs_PutChunkIntoFile(in, tags.chunkId, chunk,1))
                                                alloc_failed = 1;
                                }
-                               
+
                                endpos =
                                    (tags.chunkId - 1) * dev->nDataBytesPerChunk +
                                    tags.byteCount;
-                               if (in && 
+                               if (in &&
                                    in->variantType == YAFFS_OBJECT_TYPE_FILE
                                    && in->variant.fileVariant.scannedFileSize <
                                    endpos) {
@@ -5613,7 +5613,7 @@ static int yaffs_Scan(yaffs_Device * dev)
                                                              tags.objectId);
                                if (in && in->variantType != oh->type) {
                                        /* This should not happen, but somehow
-                                        * Wev'e ended up with an objectId that has been reused but not yet 
+                                        * Wev'e ended up with an objectId that has been reused but not yet
                                         * deleted, and worse still it has changed type. Delete the old object.
                                         */
 
@@ -5629,7 +5629,7 @@ static int yaffs_Scan(yaffs_Device * dev)
 
                                if(!in)
                                        alloc_failed = 1;
-                                       
+
                                if (in && oh->shadowsObject > 0) {
                                        yaffs_HandleShadowedObject(dev,
                                                                   oh->
@@ -5752,11 +5752,11 @@ static int yaffs_Scan(yaffs_Device * dev)
                                         * Since we might scan a hardlink before its equivalent object is scanned
                                         * we put them all in a list.
                                         * After scanning is complete, we should have all the objects, so we run through this
-                                        * list and fix up all the chains.              
+                                        * list and fix up all the chains.
                                         */
 
                                        switch (in->variantType) {
-                                       case YAFFS_OBJECT_TYPE_UNKNOWN: 
+                                       case YAFFS_OBJECT_TYPE_UNKNOWN:
                                                /* Todo got a problem */
                                                break;
                                        case YAFFS_OBJECT_TYPE_FILE:
@@ -5791,7 +5791,7 @@ static int yaffs_Scan(yaffs_Device * dev)
                                        case YAFFS_OBJECT_TYPE_SPECIAL:
                                                /* Do nothing */
                                                break;
-                                       case YAFFS_OBJECT_TYPE_SYMLINK: 
+                                       case YAFFS_OBJECT_TYPE_SYMLINK:
                                                in->variant.symLinkVariant.alias =
                                                    yaffs_CloneString(oh->alias);
                                                if(!in->variant.symLinkVariant.alias)
@@ -5826,11 +5826,11 @@ static int yaffs_Scan(yaffs_Device * dev)
        if (blockIndex) {
                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 
+        * We should now have scanned all the objects, now it's time to add these
         * hardlinks.
         */
 
@@ -5860,9 +5860,9 @@ static int yaffs_Scan(yaffs_Device * dev)
        if(alloc_failed){
                return YAFFS_FAIL;
        }
-       
+
        T(YAFFS_TRACE_SCAN, (TSTR("yaffs_Scan ends" TENDSTR)));
-       
+
 
        return YAFFS_OK;
 }
@@ -5878,7 +5878,7 @@ static void yaffs_CheckObjectDetailsLoaded(yaffs_Object *in)
 
        if(!in)
                return;
-               
+
 #if 0
        T(YAFFS_TRACE_SCAN,(TSTR("details for object %d %s loaded" TENDSTR),
                in->objectId,
@@ -5890,7 +5890,7 @@ static void yaffs_CheckObjectDetailsLoaded(yaffs_Object *in)
                chunkData = yaffs_GetTempBuffer(dev, __LINE__);
 
                result = yaffs_ReadChunkWithTagsFromNAND(dev,in->chunkId,chunkData,&tags);
-               oh = (yaffs_ObjectHeader *) chunkData;          
+               oh = (yaffs_ObjectHeader *) chunkData;
 
                in->yst_mode = oh->yst_mode;
 #ifdef CONFIG_YAFFS_WINCE
@@ -5907,17 +5907,17 @@ static void yaffs_CheckObjectDetailsLoaded(yaffs_Object *in)
                in->yst_mtime = oh->yst_mtime;
                in->yst_ctime = oh->yst_ctime;
                in->yst_rdev = oh->yst_rdev;
-               
+
 #endif
                yaffs_SetObjectName(in, oh->name);
-               
+
                if(in->variantType == YAFFS_OBJECT_TYPE_SYMLINK){
                         in->variant.symLinkVariant.alias =
                                                    yaffs_CloneString(oh->alias);
                        if(!in->variant.symLinkVariant.alias)
                                alloc_failed = 1; /* Not returned to caller */
                }
-                                                   
+
                yaffs_ReleaseTempBuffer(dev,chunkData, __LINE__);
        }
 }
@@ -5945,13 +5945,13 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
        int nBlocks = dev->internalEndBlock - dev->internalStartBlock + 1;
        int itsUnlinked;
        __u8 *chunkData;
-       
+
        int fileSize;
        int isShrink;
        int foundChunksInBlock;
        int equivalentObjectId;
        int alloc_failed = 0;
-       
+
 
        yaffs_BlockIndex *blockIndex = NULL;
        int altBlockIndex = 0;
@@ -5971,20 +5971,20 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
        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;
        }
-       
+
        dev->blocksInCheckpoint = 0;
-       
+
        chunkData = yaffs_GetTempBuffer(dev, __LINE__);
 
        /* Scan all the blocks to determine their state */
@@ -6001,15 +6001,15 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
 
                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_CHECKPOINT){
                        dev->blocksInCheckpoint++;
-                       
+
                } else if (state == YAFFS_BLOCK_STATE_DEAD) {
                        T(YAFFS_TRACE_BAD_BLOCKS,
                          (TSTR("block %d is bad" TENDSTR), blk));
@@ -6058,7 +6058,7 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
 #else
        {
                /* Dungy old bubble sort... */
-               
+
                yaffs_BlockIndex temp;
                int i;
                int j;
@@ -6094,22 +6094,22 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
                blk = blockIndex[blockIterator].block;
 
                bi = yaffs_GetBlockInfo(dev, blk);
-               
-               
+
+
                state = bi->blockState;
 
                deleted = 0;
 
                /* For each chunk in each block that needs scanning.... */
                foundChunksInBlock = 0;
-               for (c = dev->nChunksPerBlock - 1; 
+               for (c = dev->nChunksPerBlock - 1;
                     !alloc_failed && c >= 0 &&
                     (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING ||
                      state == YAFFS_BLOCK_STATE_ALLOCATING); c--) {
-                       /* Scan backwards... 
+                       /* Scan backwards...
                         * Read the tags and decide what to do
                         */
-                       
+
                        chunk = blk * dev->nChunksPerBlock + c;
 
                        result = yaffs_ReadChunkWithTagsFromNAND(dev, chunk, NULL,
@@ -6123,14 +6123,14 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
                                 * 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 
+                                * chunk and his means that either the block is empty or
                                 * this is the one being allocated from
                                 */
 
                                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;
@@ -6140,7 +6140,7 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
                                            state == YAFFS_BLOCK_STATE_ALLOCATING) {
                                                if(dev->sequenceNumber == bi->sequenceNumber) {
                                                        /* this is the block being allocated from */
-                                               
+
                                                        T(YAFFS_TRACE_SCAN,
                                                          (TSTR
                                                           (" Allocating from %d %d"
@@ -6149,34 +6149,34 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
                                                        state = YAFFS_BLOCK_STATE_ALLOCATING;
                                                        dev->allocationBlock = blk;
                                                        dev->allocationPage = c;
-                                                       dev->allocationBlockFinder = blk;       
+                                                       dev->allocationBlockFinder = blk;
                                                }
                                                else {
                                                        /* This is a partially written block that is not
                                                         * the current allocation block. This block must have
                                                         * had a write failure, so set up for retirement.
                                                         */
-                                                 
+
                                                         bi->needsRetiring = 1;
                                                         bi->gcPrioritise = 1;
-                                                                                                        
+
                                                         T(YAFFS_TRACE_ALWAYS,
                                                         (TSTR("Partially written block %d being set for retirement" TENDSTR),
                                                         blk));
                                                }
 
                                        }
-                                        
+
                                }
 
                                dev->nFreeChunks++;
-                               
+
                        } else if (tags.chunkId > 0) {
                                /* chunkId > 0 so it is a data chunk... */
                                unsigned int endpos;
                                __u32 chunkBase =
                                    (tags.chunkId - 1) * dev->nDataBytesPerChunk;
-                                                               
+
                                foundChunksInBlock = 1;
 
 
@@ -6191,7 +6191,7 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
                                        /* Out of memory */
                                        alloc_failed = 1;
                                }
-                               
+
                                if (in &&
                                    in->variantType == YAFFS_OBJECT_TYPE_FILE
                                    && chunkBase <
@@ -6202,14 +6202,14 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
                                                alloc_failed = 1;
                                        }
 
-                                       /* File size is calculated by looking at the data chunks if we have not 
+                                       /* 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;
-                                           
+
                                        if (!in->valid &&       /* have not got an object header yet */
                                            in->variant.fileVariant.
                                            scannedFileSize < endpos) {
@@ -6255,7 +6255,7 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
                                    ) {
 
                                        /* If we don't have  valid info then we need to read the chunk
-                                        * TODO In future we can probably defer reading the chunk and 
+                                        * TODO In future we can probably defer reading the chunk and
                                         * living with invalid data until needed.
                                         */
 
@@ -6283,12 +6283,12 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
 
                                if (in->valid) {
                                        /* We have already filled this one.
-                                        * We have a duplicate that will be discarded, but 
+                                        * We have a duplicate that will be discarded, but
                                         * we first have to suck out resize info if it is a file.
                                         */
 
-                                       if ((in->variantType == YAFFS_OBJECT_TYPE_FILE) && 
-                                            ((oh && 
+                                       if ((in->variantType == YAFFS_OBJECT_TYPE_FILE) &&
+                                            ((oh &&
                                               oh-> type == YAFFS_OBJECT_TYPE_FILE)||
                                              (tags.extraHeaderInfoAvailable  &&
                                               tags.extraObjectType == YAFFS_OBJECT_TYPE_FILE))
@@ -6339,7 +6339,7 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
                                     YAFFS_OBJECTID_LOSTNFOUND)) {
                                        /* We only load some info, don't fiddle with directory structure */
                                        in->valid = 1;
-                                       
+
                                        if(oh) {
                                                in->variantType = oh->type;
 
@@ -6358,13 +6358,13 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
                                                in->yst_mtime = oh->yst_mtime;
                                                in->yst_ctime = oh->yst_ctime;
                                                in->yst_rdev = oh->yst_rdev;
-               
+
 #endif
                                        } else {
                                                in->variantType = tags.extraObjectType;
                                                in->lazyLoaded = 1;
                                        }
-                                               
+
                                        in->chunkId = chunk;
 
                                } else if (!in->valid) {
@@ -6372,7 +6372,7 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
 
                                        in->valid = 1;
                                        in->chunkId = chunk;
-                                       
+
                                        if(oh) {
                                                in->variantType = oh->type;
 
@@ -6393,12 +6393,12 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
                                                in->yst_rdev = oh->yst_rdev;
 #endif
 
-                                               if (oh->shadowsObject > 0) 
+                                               if (oh->shadowsObject > 0)
                                                        yaffs_HandleShadowedObject(dev,
                                                                           oh->
                                                                           shadowsObject,
                                                                           1);
-                                       
+
 
                                                yaffs_SetObjectName(in, oh->name);
                                                parent =
@@ -6466,11 +6466,11 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
                                         * Since we might scan a hardlink before its equivalent object is scanned
                                         * we put them all in a list.
                                         * After scanning is complete, we should have all the objects, so we run
-                                        * through this list and fix up all the chains.              
+                                        * through this list and fix up all the chains.
                                         */
 
                                        switch (in->variantType) {
-                                       case YAFFS_OBJECT_TYPE_UNKNOWN: 
+                                       case YAFFS_OBJECT_TYPE_UNKNOWN:
                                                /* Todo got a problem */
                                                break;
                                        case YAFFS_OBJECT_TYPE_FILE:
@@ -6479,7 +6479,7 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
                                                    scannedFileSize < fileSize) {
                                                        /* This covers the case where the file size is greater
                                                         * than where the data is
-                                                        * This will happen if the file is resized to be larger 
+                                                        * This will happen if the file is resized to be larger
                                                         * than its current data extents.
                                                         */
                                                        in->variant.fileVariant.fileSize = fileSize;
@@ -6520,7 +6520,7 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
                                        }
 
                                }
-                               
+
                        }
 
                } /* End of scanning for each chunk */
@@ -6541,19 +6541,19 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
 
        }
 
-       if (altBlockIndex) 
+       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 
+        * We should now have scanned all the objects, now it's time to add these
         * hardlinks.
         */
        yaffs_HardlinkFixup(dev,hardList);
-       
-       
+
+
        /*
        *  Sort out state of unlinked and deleted objects.
        */
@@ -6586,7 +6586,7 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
        }
 
        yaffs_ReleaseTempBuffer(dev, chunkData, __LINE__);
-       
+
        if(alloc_failed){
                return YAFFS_FAIL;
        }
@@ -6601,10 +6601,10 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
 static void yaffs_RemoveObjectFromDirectory(yaffs_Object * obj)
 {
        yaffs_Device *dev = obj->myDev;
-       
+
        if(dev && dev->removeObjectCallback)
                dev->removeObjectCallback(obj);
-          
+
        list_del_init(&obj->siblings);
        obj->parent = NULL;
 }
@@ -6682,7 +6682,7 @@ yaffs_Object *yaffs_FindObjectByName(yaffs_Object * directory,
        list_for_each(i, &directory->variant.directoryVariant.children) {
                if (i) {
                        l = list_entry(i, yaffs_Object, siblings);
-                       
+
                        yaffs_CheckObjectDetailsLoaded(l);
 
                        /* Special case for lost-n-found */
@@ -6690,7 +6690,7 @@ yaffs_Object *yaffs_FindObjectByName(yaffs_Object * directory,
                                if (yaffs_strcmp(name, YAFFS_LOSTNFOUND_NAME) == 0) {
                                        return l;
                                }
-                       } else if (yaffs_SumCompare(l->sum, sum) || l->chunkId <= 0)    
+                       } else if (yaffs_SumCompare(l->sum, sum) || l->chunkId <= 0)
                        {
                                /* LostnFound cunk called Objxxx
                                 * Do a real check
@@ -6762,7 +6762,7 @@ yaffs_Object *yaffs_GetEquivalentObject(yaffs_Object * obj)
 int yaffs_GetObjectName(yaffs_Object * obj, YCHAR * name, int buffSize)
 {
        memset(name, 0, buffSize * sizeof(YCHAR));
-       
+
        yaffs_CheckObjectDetailsLoaded(obj);
 
        if (obj->objectId == YAFFS_OBJECTID_LOSTNFOUND) {
@@ -6994,13 +6994,13 @@ static int yaffs_CheckDevFunctions(const yaffs_Device * dev)
 static int yaffs_CreateInitialDirectories(yaffs_Device *dev)
 {
        /* Initialise the unlinked, deleted, root and lost and found directories */
-       
+
        dev->lostNFoundDir = dev->rootDir =  NULL;
        dev->unlinkedDir = dev->deletedDir = NULL;
 
        dev->unlinkedDir =
            yaffs_CreateFakeDirectory(dev, YAFFS_OBJECTID_UNLINKED, S_IFDIR);
-       
+
        dev->deletedDir =
            yaffs_CreateFakeDirectory(dev, YAFFS_OBJECTID_DELETED, S_IFDIR);
 
@@ -7010,12 +7010,12 @@ static int yaffs_CreateInitialDirectories(yaffs_Device *dev)
        dev->lostNFoundDir =
            yaffs_CreateFakeDirectory(dev, YAFFS_OBJECTID_LOSTNFOUND,
                                      YAFFS_LOSTNFOUND_MODE | S_IFDIR);
-       
+
        if(dev->lostNFoundDir && dev->rootDir && dev->unlinkedDir && dev->deletedDir){
                yaffs_AddObjectToDirectory(dev->rootDir, dev->lostNFoundDir);
                return YAFFS_OK;
        }
-       
+
        return YAFFS_FAIL;
 }
 
@@ -7049,12 +7049,12 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
 
        /* Check geometry parameters. */
 
-       if ((dev->isYaffs2 && dev->nDataBytesPerChunk < 1024) || 
-           (!dev->isYaffs2 && dev->nDataBytesPerChunk != 512) || 
-            dev->nChunksPerBlock < 2 || 
-            dev->nReservedBlocks < 2 || 
-            dev->internalStartBlock <= 0 || 
-            dev->internalEndBlock <= 0 || 
+       if ((dev->isYaffs2 && dev->nDataBytesPerChunk < 1024) ||
+           (!dev->isYaffs2 && dev->nDataBytesPerChunk != 512) ||
+            dev->nChunksPerBlock < 2 ||
+            dev->nReservedBlocks < 2 ||
+            dev->internalStartBlock <= 0 ||
+            dev->internalEndBlock <= 0 ||
             dev->internalEndBlock <= (dev->internalStartBlock + dev->nReservedBlocks + 2)      // otherwise it is too small
            ) {
                T(YAFFS_TRACE_ALWAYS,
@@ -7100,9 +7100,9 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
 
 
        /* OK now calculate a few things for the device */
-       
+
        /*
-        *  Calculate all the chunk size manipulation numbers: 
+        *  Calculate all the chunk size manipulation numbers:
         */
         /* Start off assuming it is a power of 2 */
         dev->chunkShift = ShiftDiv(dev->nDataBytesPerChunk);
@@ -7121,7 +7121,7 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
                dev->chunkShift = 0;
                dev->chunkMask = 0;
        }
-               
+
 
        /*
         * Calculate chunkGroupBits.
@@ -7129,9 +7129,9 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
         */
 
        x = dev->nChunksPerBlock * (dev->internalEndBlock + 1);
-       
+
        bits = ShiftsGE(x);
-       
+
        /* Set up tnode width if wide tnodes are enabled. */
        if(!dev->wideTnodesDisabled){
                /* bits must be even so that we end up with 32-bit words */
@@ -7144,20 +7144,20 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
        }
        else
                dev->tnodeWidth = 16;
+
        dev->tnodeMask = (1<<dev->tnodeWidth)-1;
-               
+
        /* Level0 Tnodes are 16 bits or wider (if wide tnodes are enabled),
         * so if the bitwidth of the
         * chunk range we're using is greater than 16 we need
         * to figure out chunk shift and chunkGroupSize
         */
-                
+
        if (bits <= dev->tnodeWidth)
                dev->chunkGroupBits = 0;
        else
                dev->chunkGroupBits = bits - dev->tnodeWidth;
-               
+
 
        dev->chunkGroupSize = 1 << dev->chunkGroupBits;
 
@@ -7195,11 +7195,11 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
        /* Initialise temporary buffers and caches. */
        if(!yaffs_InitialiseTempBuffers(dev))
                init_failed = 1;
-       
+
        dev->srCache = NULL;
        dev->gcCleanupList = NULL;
-       
-       
+
+
        if (!init_failed &&
            dev->nShortOpCaches > 0) {
                int i;
@@ -7211,10 +7211,10 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
                }
 
                buf = dev->srCache =  YMALLOC(srCacheBytes);
-                   
+
                if(dev->srCache)
                        memset(dev->srCache,0,srCacheBytes);
-                  
+
                for (i = 0; i < dev->nShortOpCaches && buf; i++) {
                        dev->srCache[i].object = NULL;
                        dev->srCache[i].lastUse = 0;
@@ -7223,12 +7223,12 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
                }
                if(!buf)
                        init_failed = 1;
-                       
+
                dev->srLastUse = 0;
        }
 
        dev->cacheHits = 0;
-       
+
        if(!init_failed){
                dev->gcCleanupList = YMALLOC(dev->nChunksPerBlock * sizeof(__u32));
                if(!dev->gcCleanupList)
@@ -7240,7 +7240,7 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
        }
        if(!init_failed && !yaffs_InitialiseBlocks(dev))
                init_failed = 1;
-               
+
        yaffs_InitialiseTnodes(dev);
        yaffs_InitialiseObjects(dev);
 
@@ -7256,14 +7256,14 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
                                  (TSTR("yaffs: restored from checkpoint" TENDSTR)));
                        } else {
 
-                               /* Clean up the mess caused by an aborted checkpoint load 
-                                * and scan backwards. 
+                               /* Clean up the mess caused by an aborted checkpoint load
+                                * and scan backwards.
                                 */
                                yaffs_DeinitialiseBlocks(dev);
                                yaffs_DeinitialiseTnodes(dev);
                                yaffs_DeinitialiseObjects(dev);
-                               
-                       
+
+
                                dev->nErasedBlocks = 0;
                                dev->nFreeChunks = 0;
                                dev->allocationBlock = -1;
@@ -7275,7 +7275,7 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
 
                                if(!init_failed && !yaffs_InitialiseBlocks(dev))
                                        init_failed = 1;
-                                       
+
                                yaffs_InitialiseTnodes(dev);
                                yaffs_InitialiseObjects(dev);
 
@@ -7289,7 +7289,7 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
                        if(!yaffs_Scan(dev))
                                init_failed = 1;
        }
-               
+
        if(init_failed){
                /* Clean up the mess */
                T(YAFFS_TRACE_TRACING,
@@ -7310,7 +7310,7 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
 
        yaffs_VerifyFreeChunks(dev);
        yaffs_VerifyBlocks(dev);
-       
+
 
        T(YAFFS_TRACE_TRACING,
          (TSTR("yaffs: yaffs_GutsInitialise() done.\n" TENDSTR)));
@@ -7394,7 +7394,7 @@ int yaffs_GetNumberOfFreeChunks(yaffs_Device * dev)
 #endif
 
        nFree += dev->nDeletedFiles;
-       
+
        /* Now count the number of dirty chunks in the cache and subtract those */
 
        {
@@ -7408,12 +7408,12 @@ int yaffs_GetNumberOfFreeChunks(yaffs_Device * dev)
        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)
@@ -7429,10 +7429,10 @@ static void yaffs_VerifyFreeChunks(yaffs_Device * dev)
 {
        int counted;
        int difference;
-       
+
        if(yaffs_SkipVerification(dev))
                return;
-       
+
        counted = yaffs_CountFreeChunks(dev);
 
        difference = dev->nFreeChunks - counted;
index 59c6e75acf4c3a36f81d59179b7022be9825d178..ea06c1a38e5f0aab1d4daaf4fa54d439e8b335f9 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
 #define YAFFS_OK       1
 #define YAFFS_FAIL  0
 
-/* Give us a  Y=0x59, 
- * Give us an A=0x41, 
- * Give us an FF=0xFF 
+/* Give us a  Y=0x59,
+ * Give us an A=0x41,
+ * Give us an FF=0xFF
  * Give us an S=0x53
- * And what have we got... 
+ * And what have we got...
  */
 #define YAFFS_MAGIC                    0x5941FF53
 
  * The range is limited slightly to help distinguish bad numbers from good.
  * This also allows us to perhaps in the future use special numbers for
  * special purposes.
- * EFFFFF00 allows the allocation of 8 blocks per second (~1Mbytes) for 15 years, 
+ * EFFFFF00 allows the allocation of 8 blocks per second (~1Mbytes) for 15 years,
  * and is a larger number than the lifetime of a 2GB device.
  */
 #define YAFFS_LOWEST_SEQUENCE_NUMBER   0x00001000
@@ -178,7 +178,7 @@ typedef struct {
 
        /* The following stuff only has meaning when we read */
        yaffs_ECCResult eccResult;
-       unsigned blockBad;      
+       unsigned blockBad;
 
        /* YAFFS 1 stuff */
        unsigned chunkDeleted;  /* The chunk is marked deleted */
@@ -244,29 +244,29 @@ typedef enum {
        /* This block is empty */
 
        YAFFS_BLOCK_STATE_ALLOCATING,
-       /* This block is partially allocated. 
+       /* This block is partially allocated.
         * At least one page holds valid data.
         * This is the one currently being used for page
         * allocation. Should never be more than one of these
         */
 
-       YAFFS_BLOCK_STATE_FULL, 
+       YAFFS_BLOCK_STATE_FULL,
        /* All the pages in this block have been allocated.
         */
 
        YAFFS_BLOCK_STATE_DIRTY,
-       /* All pages have been allocated and deleted. 
+       /* All pages have been allocated and deleted.
         * Erase me, reuse me.
         */
 
-       YAFFS_BLOCK_STATE_CHECKPOINT,   
+       YAFFS_BLOCK_STATE_CHECKPOINT,
        /* This block is assigned to holding checkpoint data.
         */
 
-       YAFFS_BLOCK_STATE_COLLECTING,   
+       YAFFS_BLOCK_STATE_COLLECTING,
        /* This block is being garbage collected */
 
-       YAFFS_BLOCK_STATE_DEAD  
+       YAFFS_BLOCK_STATE_DEAD
        /* This block has failed and is not in use */
 } yaffs_BlockState;
 
@@ -281,7 +281,7 @@ typedef struct {
        __u32 needsRetiring:1;  /* Data has failed on this block, need to get valid data off */
                                /* and retire the block. */
        __u32 skipErasedCheck: 1; /* If this is set we can skip the erased check on this block */
-       __u32 gcPrioritise: 1;  /* An ECC check or blank check has failed on this block. 
+       __u32 gcPrioritise: 1;  /* An ECC check or blank check has failed on this block.
                                   It should be prioritised for GC */
         __u32 chunkErrorStrikes:3; /* How many times we've had ecc etc failures on this block and tried to reuse it */
 
@@ -408,7 +408,7 @@ struct yaffs_ObjectStruct {
        __u8 renameAllowed:1;   /* Some objects are not allowed to be renamed. */
        __u8 unlinkAllowed:1;
        __u8 dirty:1;           /* the object needs to be written to flash */
-       __u8 valid:1;           /* When the file system is being loaded up, this 
+       __u8 valid:1;           /* When the file system is being loaded up, this
                                 * object might be created before the data
                                 * is available (ie. file data records appear before the header).
                                 */
@@ -430,11 +430,11 @@ struct yaffs_ObjectStruct {
 
        /* directory structure stuff */
        /* also used for linking up the free list */
-       struct yaffs_ObjectStruct *parent; 
+       struct yaffs_ObjectStruct *parent;
        struct list_head siblings;
 
        /* Where's my object header in NAND? */
-       int chunkId;            
+       int chunkId;
 
        int nDataChunks;        /* Number of data chunks attached to the file. */
 
@@ -490,26 +490,26 @@ typedef struct {
 } yaffs_ObjectBucket;
 
 
-/* yaffs_CheckpointObject holds the definition of an object as dumped 
+/* yaffs_CheckpointObject holds the definition of an object as dumped
  * by checkpointing.
  */
 
 typedef struct {
         int structType;
-       __u32 objectId;         
+       __u32 objectId;
        __u32 parentId;
        int chunkId;
-                       
+
        yaffs_ObjectType variantType:3;
-       __u8 deleted:1;         
-       __u8 softDeleted:1;     
-       __u8 unlinked:1;        
-       __u8 fake:1;            
+       __u8 deleted:1;
+       __u8 softDeleted:1;
+       __u8 unlinked:1;
+       __u8 fake:1;
        __u8 renameAllowed:1;
        __u8 unlinkAllowed:1;
-       __u8 serial;            
-       
-       int nDataChunks;        
+       __u8 serial;
+
+       int nDataChunks;
        __u32 fileSizeOrEquivalentObjectId;
 
 }yaffs_CheckpointObject;
@@ -539,14 +539,14 @@ struct yaffs_DeviceStruct {
        int endBlock;           /* End block we're allowed to use */
        int nReservedBlocks;    /* We want this tuneable so that we can reduce */
                                /* reserved blocks on NOR and RAM. */
-       
-       
+
+
        /* Stuff used by the shared space checkpointing mechanism */
        /* If this value is zero, then this mechanism is disabled */
-       
+
        int nCheckpointReservedBlocks; /* Blocks to reserve for checkpoint data */
 
-       
+
 
 
        int nShortOpCaches;     /* If <= 0, then short op caching is disabled, else
@@ -561,7 +561,7 @@ struct yaffs_DeviceStruct {
                                 * On an mtd this holds the mtd pointer.
                                 */
         void *superBlock;
-        
+
        /* NAND access functions (Must be set before calling YAFFS)*/
 
        int (*writeChunkToNAND) (struct yaffs_DeviceStruct * dev,
@@ -587,21 +587,21 @@ struct yaffs_DeviceStruct {
 #endif
 
        int isYaffs2;
-       
-       /* The removeObjectCallback function must be supplied by OS flavours that 
+
+       /* The removeObjectCallback function must be supplied by OS flavours that
         * need it. The Linux kernel does not use this, but yaffs direct does use
         * it to implement the faster readdir
         */
        void (*removeObjectCallback)(struct yaffs_ObjectStruct *obj);
-       
+
        /* Callback to mark the superblock dirsty */
        void (*markSuperBlockDirty)(void * superblock);
-       
+
        int wideTnodesDisabled; /* Set to disable wide tnodes */
-       
+
 
        /* End of stuff that must be set before initialisation. */
-       
+
        /* Checkpoint control. Can be set before or after initialisation */
        __u8 skipCheckpointRead;
        __u8 skipCheckpointWrite;
@@ -610,34 +610,34 @@ struct yaffs_DeviceStruct {
 
        __u16 chunkGroupBits;   /* 0 for devices <= 32MB. else log2(nchunks) - 16 */
        __u16 chunkGroupSize;   /* == 2^^chunkGroupBits */
-       
+
        /* Stuff to support wide tnodes */
        __u32 tnodeWidth;
        __u32 tnodeMask;
-       
+
        /* Stuff to support various file offses to chunk/offset translations */
        /* "Crumbs" for nDataBytesPerChunk not being a power of 2 */
        __u32 crumbMask;
        __u32 crumbShift;
        __u32 crumbsPerChunk;
-       
+
        /* Straight shifting for nDataBytesPerChunk being a power of 2 */
        __u32 chunkShift;
        __u32 chunkMask;
-       
+
 
 #ifdef __KERNEL__
 
        struct semaphore sem;   /* Semaphore for waiting on erasure.*/
        struct semaphore grossLock;     /* Gross locking semaphore */
-       __u8 *spareBuffer;      /* For mtdif2 use. Don't know the size of the buffer 
+       __u8 *spareBuffer;      /* For mtdif2 use. Don't know the size of the buffer
                                 * at compile time so we have to allocate it.
                                 */
        void (*putSuperFunc) (struct super_block * sb);
 #endif
 
        int isMounted;
-       
+
        int isCheckpointed;
 
 
@@ -646,7 +646,7 @@ struct yaffs_DeviceStruct {
        int internalEndBlock;
        int blockOffset;
        int chunkOffset;
-       
+
 
        /* Runtime checkpointing stuff */
        int checkpointPageSequence;   /* running sequence number of checkpoint pages */
@@ -662,13 +662,13 @@ struct yaffs_DeviceStruct {
        int checkpointMaxBlocks;
        __u32 checkpointSum;
        __u32 checkpointXor;
-       
+
        /* Block Info */
        yaffs_BlockInfo *blockInfo;
        __u8 *chunkBits;        /* bitmap of chunks in use */
        unsigned blockInfoAlt:1;        /* was allocated using alternative strategy */
        unsigned chunkBitsAlt:1;        /* was allocated using alternative strategy */
-       int chunkBitmapStride;  /* Number of bytes of chunkBits per block. 
+       int chunkBitmapStride;  /* Number of bytes of chunkBits per block.
                                 * Must be consistent with nChunksPerBlock.
                                 */
 
@@ -716,7 +716,7 @@ struct yaffs_DeviceStruct {
        int tagsEccUnfixed;
        int nDeletions;
        int nUnmarkedDeletions;
-       
+
        int hasPendingPrioritisedGCs; /* We think this device might have pending prioritised gcs */
 
        /* Special directories */
@@ -727,7 +727,7 @@ struct yaffs_DeviceStruct {
         *      __u8            bufferedData[YAFFS_CHUNKS_PER_BLOCK][YAFFS_BYTES_PER_CHUNK];
         *      yaffs_Spare bufferedSpare[YAFFS_CHUNKS_PER_BLOCK];
         */
-       
+
        int bufferedBlock;      /* Which block is buffered here? */
        int doingBufferedBlockRewrite;
 
@@ -768,7 +768,7 @@ typedef struct {
        int endBlock;
        int rfu[100];
 } yaffs_SuperBlockHeader;
-       
+
 /* The CheckpointDevice structure holds the device information that changes at runtime and
  * must be preserved over unmount/mount cycles.
  */
index 6e2a9de22267318f34bb7c42deabdea3a3e8dca8..466e5a44c6d548ef64f3a144941e112caab1e803 100644 (file)
@@ -172,7 +172,7 @@ int nandmtd_ReadChunkFromNAND(yaffs_Device * dev, int chunkInNAND, __u8 * data,
        __u8 *spareAsBytes = (__u8 *) spare;
 
        if (data && spare) {
-               if (dev->useNANDECC) {  
+               if (dev->useNANDECC) {
                        /* Careful, this call adds 2 ints */
                        /* to the end of the spare data.  Calling function */
                        /* should allocate enough memory for spare, */
index f75e08c23a40ef11f825f0e1e6701c579a2d111c..317600cac972c8f1b3af48652a9cff64e6a563d9 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
index ebf6647e838d7186130ea8f2ae9733b219a3bf17..6ea675611d0dcd3525bac6047031d3e2788bd990 100644 (file)
@@ -30,9 +30,9 @@ Message-Id: <200705181006.49860.ian@brightstareng.com>
 X-Virus-Scanned: by amavisd-new at brightstareng.com
 Status: R
 X-Status: NT
-X-KMail-EncryptionState:  
-X-KMail-SignatureState:  
-X-KMail-MDN-Sent:  
+X-KMail-EncryptionState:
+X-KMail-SignatureState:
+X-KMail-MDN-Sent:
 
 --Boundary-00=_5LbTGmt62YoutxM
 Content-Type: text/plain;
@@ -49,9 +49,9 @@ On Friday 18 May 2007 08:34, you wrote:
 
 Good news!
 
-Attached is a newer yaffs_mtdif1.c with a bandaid to help the 
+Attached is a newer yaffs_mtdif1.c with a bandaid to help the
 2.6.18 and 2.6.19 versions of MTD not trip on the oob read.
-See the LINUX_VERSION_CODE conditional in 
+See the LINUX_VERSION_CODE conditional in
 nandmtd1_ReadChunkWithTagsFromNAND.
 
 -imcd
@@ -361,7 +361,7 @@ int nandmtd1_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo)
 }
 
 /* Check any MTD prerequists.
- * 
+ *
  * Returns YAFFS_OK or YAFFS_FAIL.
  */
 static int nandmtd1_TestPrerequists(struct mtd_info * mtd)
index 15b5a970462ca96a73e8d2cee57ac4c9d43a9122..36d5adec5c9b94f76abd770fb40dc990b5e4d4df 100644 (file)
@@ -295,7 +295,7 @@ int nandmtd1_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo)
 }
 
 /* Check any MTD prerequists.
- * 
+ *
  * Returns YAFFS_OK or YAFFS_FAIL.
  */
 static int nandmtd1_TestPrerequists(struct mtd_info * mtd)
index d927c76737ebc796c0bdaf2f50efa5515010bc54..cdad0734bf958d6cd97dabe66f5a9f9788a985a9 100644 (file)
@@ -158,7 +158,7 @@ int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND,
 
        if (tags)
                yaffs_UnpackTags2(tags, &pt);
-       
+
        if(tags && retval == -EBADMSG && tags->eccResult == YAFFS_ECC_RESULT_NO_ERROR)
                tags->eccResult = YAFFS_ECC_RESULT_UNFIXED;
 
index e70d751c21eb9d188a0785df60a8db7bbcf33c1b..b67ba52aa42771448a3b3120dc7d947e034338be 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
index c33483c3599b8caadd5dd459514ac355ef96bb82..4e250338d741a2ca67af9bc268f9c1ac5949d10d 100644 (file)
@@ -10,7 +10,7 @@
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  */
+
 const char *yaffs_nand_c_version =
     "$Id: yaffs_nand.c,v 1.7 2007-02-14 01:09:06 wookey Exp $";
 
@@ -25,9 +25,9 @@ int yaffs_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND,
 {
        int result;
        yaffs_ExtendedTags localTags;
-       
+
        int realignedChunkInNAND = chunkInNAND - dev->chunkOffset;
-       
+
        /* If there are no tags provided, use local tags to get prioritised gc working */
        if(!tags)
                tags = &localTags;
@@ -39,14 +39,14 @@ int yaffs_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND,
                result = yaffs_TagsCompatabilityReadChunkWithTagsFromNAND(dev,
                                                                        realignedChunkInNAND,
                                                                        buffer,
-                                                                       tags);  
-       if(tags && 
+                                                                       tags);
+       if(tags &&
           tags->eccResult > YAFFS_ECC_RESULT_NO_ERROR){
-       
+
                yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, chunkInNAND/dev->nChunksPerBlock);
                 yaffs_HandleChunkError(dev,bi);
        }
-                                                               
+
        return result;
 }
 
@@ -57,7 +57,7 @@ int yaffs_WriteChunkWithTagsToNAND(yaffs_Device * dev,
 {
        chunkInNAND -= dev->chunkOffset;
 
-       
+
        if (tags) {
                tags->sequenceNumber = dev->sequenceNumber;
                tags->chunkUsed = 1;
@@ -131,4 +131,4 @@ int yaffs_InitialiseNAND(struct yaffs_DeviceStruct *dev)
 }
 
 
+
index 8ed1a2d5c4a39bc2bc20176741cd0e572562c06b..5fa334bdc924a8a9b2aa61807f1d39e368a7ea32 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
index 13520e10593210f4c70de42289268a88f5d4f2b9..cd2e96f7ae44468a040c78f68cb50b3b14a23096 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
index 627b2f8f5282da825cbb5a4d68302e408b0f8b41..776c5c256c24044300c518cf3e84bd535a74bc59 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
index 6860876c4389803fcbc4274d5caded7fd631cf51..e420f95da1918ae0738568ec263a731c9e8f9eee 100644 (file)
@@ -128,10 +128,10 @@ void yaffs_UnpackTags2(yaffs_ExtendedTags * t, yaffs_PackedTags2 * pt)
                                                  (yaffs_PackedTags2TagsPart),
                                                  &pt->ecc, &ecc);
                        switch(result){
-                               case 0: 
-                                       t->eccResult = YAFFS_ECC_RESULT_NO_ERROR; 
+                               case 0:
+                                       t->eccResult = YAFFS_ECC_RESULT_NO_ERROR;
                                        break;
-                               case 1: 
+                               case 1:
                                        t->eccResult = YAFFS_ECC_RESULT_FIXED;
                                        break;
                                case -1:
index 7c4a72c483daa83477db3df3a7d4247e1bfb6777..c2242ffe76220470bd94c7135d7ac29db7a363f6 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
index 0429838de8e5b4cfc1dd5b78ed1056db83b8ca8c..474be9cea39967774053d3e9756d888da07e304d 100644 (file)
@@ -50,7 +50,7 @@
 static __inline void
 swapfunc(char *a, char *b, int n, int swaptype)
 {
-       if (swaptype <= 1) 
+       if (swaptype <= 1)
                swapcode(long, a, b, n)
        else
                swapcode(char, a, b, n)
@@ -137,7 +137,7 @@ loop:       SWAPINIT(a, es);
        }
        if (swap_cnt == 0) {  /* Switch to insertion sort */
                for (pm = (char *) a + es; pm < (char *) a + n * es; pm += es)
-                       for (pl = pm; pl > (char *) a && cmp(pl - es, pl) > 0; 
+                       for (pl = pm; pl > (char *) a && cmp(pl - es, pl) > 0;
                             pl -= es)
                                swap(pl, pl - es);
                return;
@@ -150,7 +150,7 @@ loop:       SWAPINIT(a, es);
        vecswap(pb, pn - r, r);
        if ((r = pb - pa) > es)
                yaffs_qsort(a, r / es, es, cmp);
-       if ((r = pd - pc) > es) { 
+       if ((r = pd - pc) > es) {
                /* Iterate rather than recurse to save stack space */
                a = pn - r;
                n = r / es;
index 3ec73979de0488538264ed1de57148cddf843de0..610b7ec8493ad4fafe1f3ade5d3dd4e31a39a9f6 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
index c1edb6a19ab859e69c0456c6752959646ce03c12..a61e3ba14f1ffeff4937c61847112ca18ebf6356 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
index ba56727fffa837efb27039ca29deaf67602e4983..2fd0c24ed26c456cc88530d714680e68dc380311 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
index 0cfdfcf6baad48214d2c8ec21028ee7b6c1602c5..810837a32d9bb3285a62abbd674ad1e36f65f4e1 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
index 8b80c6d6889a6390eb41debb33345cce33b4b0b6..15ac28121c768bc8d9faa3d2f305bcf5e9e7bcf4 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
@@ -150,7 +150,7 @@ extern unsigned int yaffs_wr_attempts;
  * Tracing flags.
  * The flags masked in YAFFS_TRACE_ALWAYS are always traced.
  */
+
 #define YAFFS_TRACE_OS                 0x00000002
 #define YAFFS_TRACE_ALLOCATE           0x00000004
 #define YAFFS_TRACE_SCAN               0x00000008
index f55b3c5107bf35a9edd4caeb800007e35af75c73..7b6f836cdacc6890ee32413951910f2bf873c9ad 100644 (file)
@@ -26,7 +26,7 @@ config YAFFS_YAFFS1
        default y
        help
          Enable YAFFS1 support -- yaffs for 512 byte / page devices
-         
+
          Not needed for 2K-page devices.
 
          If unsure, say Y.
@@ -157,9 +157,9 @@ config YAFFS_ALWAYS_CHECK_CHUNK_ERASED
          Enabling this forces on the test that chunks are erased in flash
          before writing to them. This takes more time but is potentially
          a bit more secure.
+
          Suggest setting Y during development and ironing out driver
-         issues etc. Suggest setting to N if you want faster writing.  
+         issues etc. Suggest setting to N if you want faster writing.
 
          If unsure, say Y.
 
index 9635c7a73813f095c657f5bd7a08fc05448c73db..fcf2690a56a609bdde96d5be5339c8e523efdb13 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
@@ -15,7 +15,7 @@
 
 /*
  * This file is just holds extra declarations used during development.
- * Most of these are from kernel includes placed here so we can use them in 
+ * Most of these are from kernel includes placed here so we can use them in
  * applications.
  *
  */
index 8eb1ca314fcc229225e9aae7627d2f650c89fd8a..016391ca59e13bbe3d3ef895468d2cbbaadf757c 100644 (file)
@@ -1,10 +1,10 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
  *
- * Created by Martin Fouts <Martin.Fouts@palmsource.com> 
+ * Created by Martin Fouts <Martin.Fouts@palmsource.com>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License version 2.1 as
index 2f3f875f75a65e677c6ee24688a3804550746077..933a33fb8bfc6674954b891aa0a6e0e4b5f0701c 100644 (file)
@@ -22,27 +22,27 @@ static int yaffs_CheckpointSpaceOk(yaffs_Device *dev)
 {
 
        int blocksAvailable = dev->nErasedBlocks - dev->nReservedBlocks;
-       
+
        T(YAFFS_TRACE_CHECKPOINT,
                (TSTR("checkpt blocks available = %d" TENDSTR),
                blocksAvailable));
-               
-       
+
+
        return (blocksAvailable <= 0) ? 0 : 1;
 }
 
 
 static int yaffs_CheckpointErase(yaffs_Device *dev)
 {
-       
+
        int i;
-       
 
-       if(!dev->eraseBlockInNAND)      
+
+       if(!dev->eraseBlockInNAND)
                return 0;
        T(YAFFS_TRACE_CHECKPOINT,(TSTR("checking blocks %d to %d"TENDSTR),
                dev->internalStartBlock,dev->internalEndBlock));
-               
+
        for(i = dev->internalStartBlock; i <= dev->internalEndBlock; i++) {
                yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev,i);
                if(bi->blockState == YAFFS_BLOCK_STATE_CHECKPOINT){
@@ -58,9 +58,9 @@ static int yaffs_CheckpointErase(yaffs_Device *dev)
                        }
                }
        }
-       
+
        dev->blocksInCheckpoint = 0;
-       
+
        return 1;
 }
 
@@ -72,11 +72,11 @@ static void yaffs_CheckpointFindNextErasedBlock(yaffs_Device *dev)
        T(YAFFS_TRACE_CHECKPOINT,
                (TSTR("allocating checkpt block: erased %d reserved %d avail %d next %d "TENDSTR),
                dev->nErasedBlocks,dev->nReservedBlocks,blocksAvailable,dev->checkpointNextBlock));
-               
+
        if(dev->checkpointNextBlock >= 0 &&
           dev->checkpointNextBlock <= dev->internalEndBlock &&
           blocksAvailable > 0){
-       
+
                for(i = dev->checkpointNextBlock; i <= dev->internalEndBlock; i++){
                        yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev,i);
                        if(bi->blockState == YAFFS_BLOCK_STATE_EMPTY){
@@ -88,7 +88,7 @@ static void yaffs_CheckpointFindNextErasedBlock(yaffs_Device *dev)
                }
        }
        T(YAFFS_TRACE_CHECKPOINT,(TSTR("out of checkpt blocks"TENDSTR)));
-       
+
        dev->checkpointNextBlock = -1;
        dev->checkpointCurrentBlock = -1;
 }
@@ -97,19 +97,19 @@ static void yaffs_CheckpointFindNextCheckpointBlock(yaffs_Device *dev)
 {
        int  i;
        yaffs_ExtendedTags tags;
-       
+
        T(YAFFS_TRACE_CHECKPOINT,(TSTR("find next checkpt block: start:  blocks %d next %d" TENDSTR),
                dev->blocksInCheckpoint, dev->checkpointNextBlock));
-               
-       if(dev->blocksInCheckpoint < dev->checkpointMaxBlocks) 
+
+       if(dev->blocksInCheckpoint < dev->checkpointMaxBlocks)
                for(i = dev->checkpointNextBlock; i <= dev->internalEndBlock; i++){
                        int chunk = i * dev->nChunksPerBlock;
                        int realignedChunk = chunk - dev->chunkOffset;
 
                        dev->readChunkWithTagsFromNAND(dev,realignedChunk,NULL,&tags);
-                       T(YAFFS_TRACE_CHECKPOINT,(TSTR("find next checkpt block: search: block %d oid %d seq %d eccr %d" TENDSTR), 
+                       T(YAFFS_TRACE_CHECKPOINT,(TSTR("find next checkpt block: search: block %d oid %d seq %d eccr %d" TENDSTR),
                                i, tags.objectId,tags.sequenceNumber,tags.eccResult));
-                                                     
+
                        if(tags.sequenceNumber == YAFFS_SEQUENCE_CHECKPOINT_DATA){
                                /* Right kind of block */
                                dev->checkpointNextBlock = tags.objectId;
@@ -130,7 +130,7 @@ static void yaffs_CheckpointFindNextCheckpointBlock(yaffs_Device *dev)
 
 int yaffs_CheckpointOpen(yaffs_Device *dev, int forWriting)
 {
-       
+
        /* Got the functions we need? */
        if (!dev->writeChunkWithTagsToNAND ||
            !dev->readChunkWithTagsFromNAND ||
@@ -140,31 +140,31 @@ int yaffs_CheckpointOpen(yaffs_Device *dev, int forWriting)
 
        if(forWriting && !yaffs_CheckpointSpaceOk(dev))
                return 0;
-                       
+
        if(!dev->checkpointBuffer)
                dev->checkpointBuffer = YMALLOC_DMA(dev->nDataBytesPerChunk);
        if(!dev->checkpointBuffer)
                return 0;
 
-       
+
        dev->checkpointPageSequence = 0;
-       
+
        dev->checkpointOpenForWrite = forWriting;
-       
+
        dev->checkpointByteCount = 0;
        dev->checkpointSum = 0;
        dev->checkpointXor = 0;
        dev->checkpointCurrentBlock = -1;
        dev->checkpointCurrentChunk = -1;
        dev->checkpointNextBlock = dev->internalStartBlock;
-       
+
        /* Erase all the blocks in the checkpoint area */
        if(forWriting){
                memset(dev->checkpointBuffer,0,dev->nDataBytesPerChunk);
                dev->checkpointByteOffset = 0;
                return yaffs_CheckpointErase(dev);
-               
-               
+
+
        } else {
                int i;
                /* Set to a value that will kick off a read */
@@ -177,7 +177,7 @@ int yaffs_CheckpointOpen(yaffs_Device *dev, int forWriting)
                for(i = 0; i < dev->checkpointMaxBlocks; i++)
                        dev->checkpointBlockList[i] = -1;
        }
-       
+
        return 1;
 }
 
@@ -196,15 +196,15 @@ static int yaffs_CheckpointFlushBuffer(yaffs_Device *dev)
        int realignedChunk;
 
        yaffs_ExtendedTags tags;
-       
+
        if(dev->checkpointCurrentBlock < 0){
                yaffs_CheckpointFindNextErasedBlock(dev);
                dev->checkpointCurrentChunk = 0;
        }
-       
+
        if(dev->checkpointCurrentBlock < 0)
                return 0;
-       
+
        tags.chunkDeleted = 0;
        tags.objectId = dev->checkpointNextBlock; /* Hint to next place to look */
        tags.chunkId = dev->checkpointPageSequence + 1;
@@ -217,25 +217,25 @@ static int yaffs_CheckpointFlushBuffer(yaffs_Device *dev)
                bi->blockState = YAFFS_BLOCK_STATE_CHECKPOINT;
                dev->blocksInCheckpoint++;
        }
-       
+
        chunk = dev->checkpointCurrentBlock * dev->nChunksPerBlock + dev->checkpointCurrentChunk;
 
-       
+
        T(YAFFS_TRACE_CHECKPOINT,(TSTR("checkpoint wite buffer nand %d(%d:%d) objid %d chId %d" TENDSTR),
-               chunk, dev->checkpointCurrentBlock, dev->checkpointCurrentChunk,tags.objectId,tags.chunkId)); 
-       
+               chunk, dev->checkpointCurrentBlock, dev->checkpointCurrentChunk,tags.objectId,tags.chunkId));
+
        realignedChunk = chunk - dev->chunkOffset;
-       
+
        dev->writeChunkWithTagsToNAND(dev,realignedChunk,dev->checkpointBuffer,&tags);
        dev->checkpointByteOffset = 0;
-       dev->checkpointPageSequence++;     
+       dev->checkpointPageSequence++;
        dev->checkpointCurrentChunk++;
        if(dev->checkpointCurrentChunk >= dev->nChunksPerBlock){
                dev->checkpointCurrentChunk = 0;
                dev->checkpointCurrentBlock = -1;
        }
        memset(dev->checkpointBuffer,0,dev->nDataBytesPerChunk);
-       
+
        return 1;
 }
 
@@ -245,37 +245,37 @@ int yaffs_CheckpointWrite(yaffs_Device *dev,const void *data, int nBytes)
        int i=0;
        int ok = 1;
 
-       
+
        __u8 * dataBytes = (__u8 *)data;
-       
-       
+
+
 
        if(!dev->checkpointBuffer)
                return 0;
-               
+
        if(!dev->checkpointOpenForWrite)
                return -1;
 
        while(i < nBytes && ok) {
-               
 
-               
+
+
                dev->checkpointBuffer[dev->checkpointByteOffset] = *dataBytes ;
                dev->checkpointSum += *dataBytes;
                dev->checkpointXor ^= *dataBytes;
-                
+
                dev->checkpointByteOffset++;
                i++;
                dataBytes++;
                dev->checkpointByteCount++;
-               
-               
+
+
                if(dev->checkpointByteOffset < 0 ||
-                  dev->checkpointByteOffset >= dev->nDataBytesPerChunk) 
+                  dev->checkpointByteOffset >= dev->nDataBytesPerChunk)
                        ok = yaffs_CheckpointFlushBuffer(dev);
 
        }
-       
+
        return  i;
 }
 
@@ -285,12 +285,12 @@ int yaffs_CheckpointRead(yaffs_Device *dev, void *data, int nBytes)
        int ok = 1;
        yaffs_ExtendedTags tags;
 
-       
+
        int chunk;
        int realignedChunk;
 
        __u8 *dataBytes = (__u8 *)data;
-               
+
        if(!dev->checkpointBuffer)
                return 0;
 
@@ -298,31 +298,31 @@ int yaffs_CheckpointRead(yaffs_Device *dev, void *data, int nBytes)
                return -1;
 
        while(i < nBytes && ok) {
-       
-       
+
+
                if(dev->checkpointByteOffset < 0 ||
                   dev->checkpointByteOffset >= dev->nDataBytesPerChunk) {
-                  
+
                        if(dev->checkpointCurrentBlock < 0){
                                yaffs_CheckpointFindNextCheckpointBlock(dev);
                                dev->checkpointCurrentChunk = 0;
                        }
-                       
+
                        if(dev->checkpointCurrentBlock < 0)
                                ok = 0;
                        else {
-                       
-                               chunk = dev->checkpointCurrentBlock * dev->nChunksPerBlock + 
+
+                               chunk = dev->checkpointCurrentBlock * dev->nChunksPerBlock +
                                          dev->checkpointCurrentChunk;
 
                                realignedChunk = chunk - dev->chunkOffset;
 
                                /* read in the next chunk */
                                /* printf("read checkpoint page %d\n",dev->checkpointPage); */
-                               dev->readChunkWithTagsFromNAND(dev, realignedChunk, 
+                               dev->readChunkWithTagsFromNAND(dev, realignedChunk,
                                                               dev->checkpointBuffer,
                                                              &tags);
-                                                     
+
                                if(tags.chunkId != (dev->checkpointPageSequence + 1) ||
                                   tags.sequenceNumber != YAFFS_SEQUENCE_CHECKPOINT_DATA)
                                   ok = 0;
@@ -330,12 +330,12 @@ int yaffs_CheckpointRead(yaffs_Device *dev, void *data, int nBytes)
                                dev->checkpointByteOffset = 0;
                                dev->checkpointPageSequence++;
                                dev->checkpointCurrentChunk++;
-                       
+
                                if(dev->checkpointCurrentChunk >= dev->nChunksPerBlock)
                                        dev->checkpointCurrentBlock = -1;
                        }
                }
-               
+
                if(ok){
                        *dataBytes = dev->checkpointBuffer[dev->checkpointByteOffset];
                        dev->checkpointSum += *dataBytes;
@@ -346,14 +346,14 @@ int yaffs_CheckpointRead(yaffs_Device *dev, void *data, int nBytes)
                        dev->checkpointByteCount++;
                }
        }
-       
+
        return  i;
 }
 
 int yaffs_CheckpointClose(yaffs_Device *dev)
 {
 
-       if(dev->checkpointOpenForWrite){        
+       if(dev->checkpointOpenForWrite){
                if(dev->checkpointByteOffset != 0)
                        yaffs_CheckpointFlushBuffer(dev);
        } else {
@@ -373,19 +373,19 @@ int yaffs_CheckpointClose(yaffs_Device *dev)
        dev->nFreeChunks -= dev->blocksInCheckpoint * dev->nChunksPerBlock;
        dev->nErasedBlocks -= dev->blocksInCheckpoint;
 
-               
+
        T(YAFFS_TRACE_CHECKPOINT,(TSTR("checkpoint byte count %d" TENDSTR),
                        dev->checkpointByteCount));
-                       
+
        if(dev->checkpointBuffer){
-               /* free the buffer */   
+               /* free the buffer */
                YFREE(dev->checkpointBuffer);
                dev->checkpointBuffer = NULL;
                return 1;
        }
        else
                return 0;
-       
+
 }
 
 int yaffs_CheckpointInvalidateStream(yaffs_Device *dev)
index f4b0c7dcaaf4b03e967179df46bf3b44c8e975f0..d3ff17405f2df9409ed5516064deddadea70bcf4 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
index be860d01a6f3853695efb2a9184bb43ffe728927..e2860393d3726d5b7709afaf0b2a427e59f215e1 100644 (file)
@@ -14,9 +14,9 @@
 /*
  * This code implements the ECC algorithm used in SmartMedia.
  *
- * The ECC comprises 22 bits of parity information and is stuffed into 3 bytes. 
+ * The ECC comprises 22 bits of parity information and is stuffed into 3 bytes.
  * The two unused bit are set to 1.
- * The ECC can correct single bit errors in a 256-byte page of data. Thus, two such ECC 
+ * The ECC can correct single bit errors in a 256-byte page of data. Thus, two such ECC
  * blocks are used on a 512-byte NAND page.
  *
  */
@@ -228,8 +228,8 @@ int yaffs_ECCCorrect(unsigned char *data, unsigned char *read_ecc,
                return 1; /* Corrected the error */
        }
 
-       if ((yaffs_CountBits(d0) + 
-            yaffs_CountBits(d1) + 
+       if ((yaffs_CountBits(d0) +
+            yaffs_CountBits(d1) +
             yaffs_CountBits(d2)) ==  1) {
                /* Reccoverable error in ecc */
 
@@ -239,7 +239,7 @@ int yaffs_ECCCorrect(unsigned char *data, unsigned char *read_ecc,
 
                return 1; /* Corrected the error */
        }
-       
+
        /* Unrecoverable error */
 
        return -1;
@@ -293,7 +293,7 @@ int yaffs_ECCCorrectOther(unsigned char *data, unsigned nBytes,
        if ((cDelta | lDelta | lDeltaPrime) == 0)
                return 0; /* no error */
 
-       if (lDelta == ~lDeltaPrime && 
+       if (lDelta == ~lDeltaPrime &&
            (((cDelta ^ (cDelta >> 1)) & 0x15) == 0x15))
        {
                /* Single bit (recoverable) error in data */
@@ -309,7 +309,7 @@ int yaffs_ECCCorrectOther(unsigned char *data, unsigned nBytes,
 
                if(lDelta >= nBytes)
                        return -1;
-                       
+
                data[lDelta] ^= (1 << bit);
 
                return 1; /* corrected */
index 40fd02b9653ec750fe66ce4f991a3121e0310415..79bc3d117146d4d08f823dca2ec3700cc0c9bf9e 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
@@ -16,9 +16,9 @@
  /*
   * This code implements the ECC algorithm used in SmartMedia.
   *
-  * The ECC comprises 22 bits of parity information and is stuffed into 3 bytes. 
+  * The ECC comprises 22 bits of parity information and is stuffed into 3 bytes.
   * The two unused bit are set to 1.
-  * The ECC can correct single bit errors in a 256-byte page of data. Thus, two such ECC 
+  * The ECC can correct single bit errors in a 256-byte page of data. Thus, two such ECC
   * blocks are used on a 512-byte NAND page.
   *
   */
index e572301f5d1956a3b81970bb4f3bf7a07e52f26c..67001b10e667f3c07751ec8570a6316b134dcd20 100644 (file)
@@ -23,7 +23,7 @@
  * This is the file system front-end to YAFFS that hooks it up to
  * the VFS.
  *
- * Special notes: 
+ * Special notes:
  * >> 2.4: sb->u.generic_sbp points to the yaffs_Device associated with
  *         this superblock
  * >> 2.6: sb->s_fs_info  points to the yaffs_Device associated with this
@@ -391,7 +391,7 @@ static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry)
                                   dentry->d_name.name);
 
        obj = yaffs_GetEquivalentObject(obj);   /* in case it was a hardlink */
-       
+
        /* Can't hold gross lock when calling yaffs_get_inode() */
        yaffs_GrossUnlock(dev);
 
@@ -729,21 +729,21 @@ static void yaffs_FillInodeFromObject(struct inode *inode, yaffs_Object * obj)
                                obj->yst_mode &= ~S_IFMT;
                                obj->yst_mode |= S_IFREG;
                        }
+
                        break;
                case YAFFS_OBJECT_TYPE_SYMLINK :
                        if( ! S_ISLNK(mode) ){
                                obj->yst_mode &= ~S_IFMT;
                                obj->yst_mode |= S_IFLNK;
                        }
+
                        break;
                case YAFFS_OBJECT_TYPE_DIRECTORY :
                        if( ! S_ISDIR(mode) ){
                                obj->yst_mode &= ~S_IFMT;
                                obj->yst_mode |= S_IFDIR;
                        }
+
                        break;
                case YAFFS_OBJECT_TYPE_UNKNOWN :
                case YAFFS_OBJECT_TYPE_HARDLINK :
@@ -1020,7 +1020,7 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
        int error = -ENOSPC;
        uid_t uid = current->fsuid;
        gid_t gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->fsgid;
-       
+
        if((dir->i_mode & S_ISGID) && S_ISDIR(mode))
                mode |= S_ISGID;
 
@@ -1075,7 +1075,7 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
                obj = NULL;     /* Do we ever get here? */
                break;
        }
-       
+
        /* Can not call yaffs_get_inode() with gross lock held */
        yaffs_GrossUnlock(dev);
 
@@ -1264,13 +1264,13 @@ static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry,
        target =
            yaffs_FindObjectByName(yaffs_InodeToObject(new_dir),
                                   new_dentry->d_name.name);
-       
-       
+
+
 
        if (target &&
            target->variantType == YAFFS_OBJECT_TYPE_DIRECTORY &&
            !list_empty(&target->variant.directoryVariant.children)) {
-           
+
                T(YAFFS_TRACE_OS, (KERN_DEBUG "target is non-empty dir\n"));
 
                retVal = YAFFS_FAIL;
@@ -1278,7 +1278,7 @@ static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry,
 
                /* Now does unlinking internally using shadowing mechanism */
                T(YAFFS_TRACE_OS, (KERN_DEBUG "calling yaffs_RenameObject\n"));
-               
+
                retVal =
                    yaffs_RenameObject(yaffs_InodeToObject(old_dir),
                                       old_dentry->d_name.name,
@@ -1390,7 +1390,7 @@ static int yaffs_do_sync_fs(struct super_block *sb)
 
                if(dev)
                        yaffs_CheckpointSave(dev);
-               
+
                yaffs_GrossUnlock(dev);
 
                sb->s_dirt = 0;
@@ -1421,16 +1421,16 @@ static int yaffs_sync_fs(struct super_block *sb)
 {
 
        T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_sync_fs\n"));
-       
+
        return 0; /* yaffs_do_sync_fs(sb);*/
-       
+
 }
 
 
 static void yaffs_read_inode(struct inode *inode)
 {
        /* NB This is called as a side effect of other functions, but
-        * we had to release the lock to prevent deadlocks, so 
+        * we had to release the lock to prevent deadlocks, so
         * need to lock again.
         */
 
@@ -1441,7 +1441,7 @@ static void yaffs_read_inode(struct inode *inode)
          (KERN_DEBUG "yaffs_read_inode for %d\n", (int)inode->i_ino));
 
        yaffs_GrossLock(dev);
-       
+
        obj = yaffs_FindObjectByNumber(dev, inode->i_ino);
 
        yaffs_FillInodeFromObject(inode, obj);
@@ -1458,26 +1458,26 @@ static int yaffs_remount_fs(struct super_block *sb, int *flags, char *data)
 
        if( *flags & MS_RDONLY ) {
                struct mtd_info *mtd = yaffs_SuperToDevice(sb)->genericDevice;
-           
+
                T(YAFFS_TRACE_OS,
                        (KERN_DEBUG "yaffs_remount_fs: %s: RO\n", dev->name ));
 
                yaffs_GrossLock(dev);
-        
+
                yaffs_FlushEntireDeviceCache(dev);
-       
+
                yaffs_CheckpointSave(dev);
+
                if (mtd->sync)
                        mtd->sync(mtd);
 
                yaffs_GrossUnlock(dev);
        }
        else {
-               T(YAFFS_TRACE_OS, 
+               T(YAFFS_TRACE_OS,
                        (KERN_DEBUG "yaffs_remount_fs: %s: RW\n", dev->name ));
        }
+
        return 0;
 }
 #endif
@@ -1489,7 +1489,7 @@ static void yaffs_put_super(struct super_block *sb)
        T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_put_super\n"));
 
        yaffs_GrossLock(dev);
-       
+
        yaffs_FlushEntireDeviceCache(dev);
 
        yaffs_CheckpointSave(dev);
@@ -1499,12 +1499,12 @@ static void yaffs_put_super(struct super_block *sb)
        }
 
        yaffs_Deinitialise(dev);
-       
+
        yaffs_GrossUnlock(dev);
 
        /* we assume this is protected by lock_kernel() in mount/umount */
        list_del(&dev->devList);
-       
+
        if(dev->spareBuffer){
                YFREE(dev->spareBuffer);
                dev->spareBuffer = NULL;
@@ -1530,7 +1530,7 @@ static void yaffs_MTDPutSuper(struct super_block *sb)
 static void yaffs_MarkSuperBlockDirty(void *vsb)
 {
        struct super_block *sb = (struct super_block *)vsb;
-       
+
        T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_MarkSuperBlockDirty() sb = %p\n",sb));
 //     if(sb)
 //             sb->s_dirt = 1;
@@ -1549,13 +1549,13 @@ static int yaffs_parse_options(yaffs_options *options, const char *options_str)
        char cur_opt[MAX_OPT_LEN+1];
        int p;
        int error = 0;
-       
+
        /* Parse through the options which is a comma seperated list */
-       
+
        while(options_str && *options_str && !error){
                memset(cur_opt,0,MAX_OPT_LEN+1);
                p = 0;
-               
+
                while(*options_str && *options_str != ','){
                        if(p < MAX_OPT_LEN){
                                cur_opt[p] = *options_str;
@@ -1563,7 +1563,7 @@ static int yaffs_parse_options(yaffs_options *options, const char *options_str)
                        }
                        options_str++;
                }
-               
+
                if(!strcmp(cur_opt,"inband-tags"))
                        options->inband_tags = 1;
                else if(!strcmp(cur_opt,"no-cache"))
@@ -1579,7 +1579,7 @@ static int yaffs_parse_options(yaffs_options *options, const char *options_str)
                        printk(KERN_INFO "yaffs: Bad mount option \"%s\"\n",cur_opt);
                        error = 1;
                }
-               
+
        }
 
        return error;
@@ -1597,7 +1597,7 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion,
        struct mtd_info *mtd;
        int err;
        char *data_str = (char *)data;
-       
+
        yaffs_options options;
 
        sb->s_magic = YAFFS_MAGIC;
@@ -1613,14 +1613,14 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion,
                printk(KERN_INFO "yaffs: dev is %d name is \"%s\"\n",
                       sb->s_dev,
                       yaffs_devname(sb, devname_buf));
-                   
+
        if(!data_str)
                data_str = "";
-   
+
        printk(KERN_INFO "yaffs: passed flags \"%s\"\n",data_str);
-       
+
        memset(&options,0,sizeof(options));
-       
+
        if(yaffs_parse_options(&options,data_str)){
                /* Option parsing failed */
                return NULL;
@@ -1674,10 +1674,10 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion,
        T(YAFFS_TRACE_OS, (" oobsize %d\n", mtd->oobsize));
        T(YAFFS_TRACE_OS, (" erasesize %d\n", mtd->erasesize));
        T(YAFFS_TRACE_OS, (" size %d\n", mtd->size));
-       
+
 #ifdef CONFIG_YAFFS_AUTO_YAFFS2
 
-       if (yaffsVersion == 1 && 
+       if (yaffsVersion == 1 &&
 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
            mtd->writesize >= 2048) {
 #else
@@ -1685,10 +1685,10 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion,
 #endif
            T(YAFFS_TRACE_ALWAYS,("yaffs: auto selecting yaffs2\n"));
            yaffsVersion = 2;
-       }       
-       
+       }
+
        /* Added NCB 26/5/2006 for completeness */
-       if (yaffsVersion == 2 && 
+       if (yaffsVersion == 2 &&
 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
            mtd->writesize == 512) {
 #else
@@ -1696,7 +1696,7 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion,
 #endif
            T(YAFFS_TRACE_ALWAYS,("yaffs: auto selecting yaffs1\n"));
            yaffsVersion = 1;
-       }       
+       }
 
 #endif
 
@@ -1830,10 +1830,10 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion,
        dev->initialiseNAND = nandmtd_InitialiseNAND;
 
        dev->putSuperFunc = yaffs_MTDPutSuper;
-       
+
        dev->superBlock = (void *)sb;
        dev->markSuperBlockDirty = yaffs_MarkSuperBlockDirty;
-       
+
 
 #ifndef CONFIG_YAFFS_DOES_ECC
        dev->useNANDECC = 1;
@@ -1845,7 +1845,7 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion,
 
        dev->skipCheckpointRead = options.skip_checkpoint_read;
        dev->skipCheckpointWrite = options.skip_checkpoint_write;
-       
+
        /* we assume this is protected by lock_kernel() in mount/umount */
        list_add_tail(&dev->devList, &yaffs_dev_list);
 
@@ -1858,7 +1858,7 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion,
        T(YAFFS_TRACE_OS,
          ("yaffs_read_super: guts initialised %s\n",
           (err == YAFFS_OK) ? "OK" : "FAILED"));
-       
+
        /* Release lock before yaffs_get_inode() */
        yaffs_GrossUnlock(dev);
 
@@ -2118,7 +2118,7 @@ static int yaffs_proc_write(struct file *file, const char *buf,
        unsigned rg = 0, mask_bitfield;
        char *end;
        char *mask_name;
-       const char *x; 
+       const char *x;
        char substring[MAX_MASK_NAME_LENGTH+1];
        int i;
        int done = 0;
@@ -2146,7 +2146,7 @@ static int yaffs_proc_write(struct file *file, const char *buf,
                        break;
                }
                mask_name = NULL;
-               
+
                mask_bitfield = simple_strtoul(buf + pos, &end, 0);
                if (end > buf + pos) {
                        mask_name = "numeral";
@@ -2154,12 +2154,12 @@ static int yaffs_proc_write(struct file *file, const char *buf,
                        pos += len;
                        done = 0;
                } else {
-                       for(x = buf + pos, i = 0; 
+                       for(x = buf + pos, i = 0;
                            (*x == '_' || (*x >='a' && *x <= 'z')) &&
                            i <MAX_MASK_NAME_LENGTH; x++, i++, pos++)
                            substring[i] = *x;
                        substring[i] = '\0';
-                       
+
                        for (i = 0; mask_flags[i].mask_name != NULL; i++) {
                                if(strcmp(substring,mask_flags[i].mask_name) == 0){
                                        mask_name = mask_flags[i].mask_name;
@@ -2190,9 +2190,9 @@ static int yaffs_proc_write(struct file *file, const char *buf,
        }
 
        yaffs_traceMask = rg | YAFFS_TRACE_ALWAYS;
-       
+
        printk("new trace = 0x%08X\n",yaffs_traceMask);
-       
+
        if (rg & YAFFS_TRACE_ALWAYS) {
                for (i = 0; mask_flags[i].mask_name != NULL; i++) {
                        char flag;
index 006820c7136e88b226f2386ea79e8836cd391460..2ab814691356d3e8cd68e0c8cea1ab660bfc4df4 100644 (file)
@@ -140,71 +140,71 @@ static void yaffs_AddrToChunk(yaffs_Device *dev, loff_t addr, __u32 *chunk, __u3
                YBUG();
 }
 
-/* Function to return the number of shifts for a power of 2 greater than or equal 
+/* Function to return the number of shifts for a power of 2 greater than or equal
  * to the given number
  * Note we don't try to cater for all possible numbers and this does not have to
  * be hellishly efficient.
  */
+
 static __u32 ShiftsGE(__u32 x)
 {
        int extraBits;
        int nShifts;
-       
+
        nShifts = extraBits = 0;
-       
+
        while(x>1){
                if(x & 1) extraBits++;
                x>>=1;
                nShifts++;
        }
 
-       if(extraBits) 
+       if(extraBits)
                nShifts++;
-               
+
        return nShifts;
 }
 
 /* Function to return the number of shifts to get a 1 in bit 0
  */
+
 static __u32 ShiftDiv(__u32 x)
 {
        int nShifts;
-       
+
        nShifts =  0;
-       
+
        if(!x) return 0;
-       
+
        while( !(x&1)){
                x>>=1;
                nShifts++;
        }
-               
+
        return nShifts;
 }
 
 
 
-/* 
+/*
  * Temporary buffer manipulations.
  */
 
-static int yaffs_InitialiseTempBuffers(yaffs_Device *dev)      
+static int yaffs_InitialiseTempBuffers(yaffs_Device *dev)
 {
        int i;
        __u8 *buf = (__u8 *)1;
-               
+
        memset(dev->tempBuffer,0,sizeof(dev->tempBuffer));
-               
+
        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->nDataBytesPerChunk);
        }
-               
+
        return buf ? YAFFS_OK : YAFFS_FAIL;
-       
+
 }
 
 static __u8 *yaffs_GetTempBuffer(yaffs_Device * dev, int lineNo)
@@ -337,7 +337,7 @@ static Y_INLINE void yaffs_ClearChunkBit(yaffs_Device * dev, int blk, int chunk)
 static Y_INLINE void yaffs_SetChunkBit(yaffs_Device * dev, int blk, int chunk)
 {
        __u8 *blkBits = yaffs_BlockBits(dev, blk);
-       
+
        yaffs_VerifyChunkBitId(dev,blk,chunk);
 
        blkBits[chunk / 8] |= (1 << (chunk & 7));
@@ -375,16 +375,16 @@ static int yaffs_CountChunkBits(yaffs_Device * dev, int blk)
                                n++;
                        x >>=1;
                }
-                       
+
                blkBits++;
        }
        return n;
 }
 
-/* 
+/*
  * Verification code
  */
+
 static int yaffs_SkipVerification(yaffs_Device *dev)
 {
        return !(yaffs_traceMask & (YAFFS_TRACE_VERIFY | YAFFS_TRACE_VERIFY_FULL));
@@ -417,14 +417,14 @@ static void yaffs_VerifyBlock(yaffs_Device *dev,yaffs_BlockInfo *bi,int n)
 {
        int actuallyUsed;
        int inUse;
-       
+
        if(yaffs_SkipVerification(dev))
                return;
-               
+
        /* Report illegal runtime states */
        if(bi->blockState <0 || bi->blockState >= YAFFS_NUMBER_OF_BLOCK_STATES)
                T(YAFFS_TRACE_VERIFY,(TSTR("Block %d has undefined state %d"TENDSTR),n,bi->blockState));
-               
+
        switch(bi->blockState){
         case YAFFS_BLOCK_STATE_UNKNOWN:
         case YAFFS_BLOCK_STATE_SCANNING:
@@ -432,42 +432,42 @@ static void yaffs_VerifyBlock(yaffs_Device *dev,yaffs_BlockInfo *bi,int n)
                T(YAFFS_TRACE_VERIFY,(TSTR("Block %d has bad run-state %s"TENDSTR),
                n,blockStateName[bi->blockState]));
        }
-       
+
        /* Check pages in use and soft deletions are legal */
-       
+
        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)
                T(YAFFS_TRACE_VERIFY,(TSTR("Block %d has illegal values pagesInUsed %d softDeletions %d"TENDSTR),
                n,bi->pagesInUse,bi->softDeletions));
-       
-               
+
+
        /* Check chunk bitmap legal */
        inUse = yaffs_CountChunkBits(dev,n);
        if(inUse != bi->pagesInUse)
                T(YAFFS_TRACE_VERIFY,(TSTR("Block %d has inconsistent values pagesInUse %d counted chunk bits %d"TENDSTR),
                        n,bi->pagesInUse,inUse));
-       
+
        /* Check that the sequence number is valid.
-        * Ten million is legal, but is very unlikely 
+        * Ten million is legal, but is very unlikely
         */
-       if(dev->isYaffs2 && 
+       if(dev->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),
                n,bi->sequenceNumber));
-               
+
 }
 
 static void yaffs_VerifyCollectedBlock(yaffs_Device *dev,yaffs_BlockInfo *bi,int n)
 {
        yaffs_VerifyBlock(dev,bi,n);
-       
+
        /* After collection the block should be in the erased state */
        /* TODO: This will need to change if we do partial gc */
-       
+
        if(bi->blockState != YAFFS_BLOCK_STATE_EMPTY){
                T(YAFFS_TRACE_ERROR,(TSTR("Block %d is in state %d after gc, should be erased"TENDSTR),
                        n,bi->blockState));
@@ -479,14 +479,14 @@ static void yaffs_VerifyBlocks(yaffs_Device *dev)
        int i;
        int nBlocksPerState[YAFFS_NUMBER_OF_BLOCK_STATES];
        int nIllegalBlockStates = 0;
-       
+
 
        if(yaffs_SkipVerification(dev))
                return;
 
        memset(nBlocksPerState,0,sizeof(nBlocksPerState));
 
-               
+
        for(i = dev->internalStartBlock; i <= dev->internalEndBlock; i++){
                yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev,i);
                yaffs_VerifyBlock(dev,bi,i);
@@ -495,12 +495,12 @@ static void yaffs_VerifyBlocks(yaffs_Device *dev)
                        nBlocksPerState[bi->blockState]++;
                else
                        nIllegalBlockStates++;
-                                       
+
        }
-       
+
        T(YAFFS_TRACE_VERIFY,(TSTR(""TENDSTR)));
        T(YAFFS_TRACE_VERIFY,(TSTR("Block summary"TENDSTR)));
-       
+
        T(YAFFS_TRACE_VERIFY,(TSTR("%d blocks have illegal states"TENDSTR),nIllegalBlockStates));
        if(nBlocksPerState[YAFFS_BLOCK_STATE_ALLOCATING] > 1)
                T(YAFFS_TRACE_VERIFY,(TSTR("Too many allocating blocks"TENDSTR)));
@@ -509,17 +509,17 @@ static void yaffs_VerifyBlocks(yaffs_Device *dev)
                T(YAFFS_TRACE_VERIFY,
                  (TSTR("%s %d blocks"TENDSTR),
                  blockStateName[i],nBlocksPerState[i]));
-       
+
        if(dev->blocksInCheckpoint != nBlocksPerState[YAFFS_BLOCK_STATE_CHECKPOINT])
                T(YAFFS_TRACE_VERIFY,
                 (TSTR("Checkpoint block count wrong dev %d count %d"TENDSTR),
                 dev->blocksInCheckpoint, nBlocksPerState[YAFFS_BLOCK_STATE_CHECKPOINT]));
-                
+
        if(dev->nErasedBlocks != nBlocksPerState[YAFFS_BLOCK_STATE_EMPTY])
                T(YAFFS_TRACE_VERIFY,
                 (TSTR("Erased block count wrong dev %d count %d"TENDSTR),
                 dev->nErasedBlocks, nBlocksPerState[YAFFS_BLOCK_STATE_EMPTY]));
-                
+
        if(nBlocksPerState[YAFFS_BLOCK_STATE_COLLECTING] > 1)
                T(YAFFS_TRACE_VERIFY,
                 (TSTR("Too many collecting blocks %d (max is 1)"TENDSTR),
@@ -537,14 +537,14 @@ static void yaffs_VerifyObjectHeader(yaffs_Object *obj, yaffs_ObjectHeader *oh,
 {
        if(yaffs_SkipVerification(obj->myDev))
                return;
-               
+
        if(!(tags && obj && oh)){
                T(YAFFS_TRACE_VERIFY,
                                (TSTR("Verifying object header tags %x obj %x oh %x"TENDSTR),
                                (__u32)tags,(__u32)obj,(__u32)oh));
                return;
        }
-       
+
        if(oh->type <= YAFFS_OBJECT_TYPE_UNKNOWN ||
           oh->type > YAFFS_OBJECT_TYPE_MAX)
                T(YAFFS_TRACE_VERIFY,
@@ -559,25 +559,25 @@ static void yaffs_VerifyObjectHeader(yaffs_Object *obj, yaffs_ObjectHeader *oh,
 
        /*
         * Check that the object's parent ids match if parentCheck requested.
-        * 
+        *
         * Tests do not apply to the root object.
         */
-       
+
        if(parentCheck && tags->objectId > 1 && !obj->parent)
                T(YAFFS_TRACE_VERIFY,
                 (TSTR("Obj %d header mismatch parentId %d obj->parent is NULL"TENDSTR),
                 tags->objectId, oh->parentObjectId));
-               
-       
+
+
        if(parentCheck && obj->parent &&
-          oh->parentObjectId != obj->parent->objectId && 
+          oh->parentObjectId != obj->parent->objectId &&
           (oh->parentObjectId != YAFFS_OBJECTID_UNLINKED ||
            obj->parent->objectId != YAFFS_OBJECTID_DELETED))
                T(YAFFS_TRACE_VERIFY,
                 (TSTR("Obj %d header mismatch parentId %d parentObjectId %d"TENDSTR),
                 tags->objectId, oh->parentObjectId, obj->parent->objectId));
-               
-       
+
+
        if(tags->objectId > 1 && oh->name[0] == 0) /* Null name */
                T(YAFFS_TRACE_VERIFY,
                (TSTR("Obj %d header name is NULL"TENDSTR),
@@ -614,12 +614,12 @@ static int yaffs_VerifyTnodeWorker(yaffs_Object * obj, yaffs_Tnode * tn,
                        int i;
                        yaffs_ExtendedTags tags;
                        __u32 objectId = obj->objectId;
-                       
+
                        chunkOffset <<=  YAFFS_TNODES_LEVEL0_BITS;
-                       
+
                        for(i = 0; i < YAFFS_NTNODES_LEVEL0; i++){
                                __u32 theChunk = yaffs_GetChunkGroupBase(dev,tn,i);
-                               
+
                                if(theChunk > 0){
                                        /* T(~0,(TSTR("verifying (%d:%d) %d"TENDSTR),tags.objectId,tags.chunkId,theChunk)); */
                                        yaffs_ReadChunkWithTagsFromNAND(dev,theChunk,NULL, &tags);
@@ -651,13 +651,13 @@ static void yaffs_VerifyFile(yaffs_Object *obj)
        yaffs_ExtendedTags tags;
        yaffs_Tnode *tn;
        __u32 objectId;
-       
+
        if(obj && yaffs_SkipVerification(obj->myDev))
                return;
-       
+
        dev = obj->myDev;
        objectId = obj->objectId;
-       
+
        /* Check file size is consistent with tnode depth */
        lastChunk =  obj->variant.fileVariant.fileSize / dev->nDataBytesPerChunk + 1;
        x = lastChunk >> YAFFS_TNODES_LEVEL0_BITS;
@@ -666,23 +666,23 @@ static void yaffs_VerifyFile(yaffs_Object *obj)
                x >>= YAFFS_TNODES_INTERNAL_BITS;
                requiredTallness++;
        }
-       
+
        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. 
+
+
+       /* 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.
         */
 
        if(yaffs_SkipNANDVerification(dev))
                return;
-               
+
        for(i = 1; i <= lastChunk; i++){
                tn = yaffs_FindLevel0Tnode(dev, &obj->variant.fileVariant,i);
 
@@ -707,14 +707,14 @@ static void yaffs_VerifyDirectory(yaffs_Object *obj)
 {
        if(obj && yaffs_SkipVerification(obj->myDev))
                return;
-       
+
 }
 
 static void yaffs_VerifyHardLink(yaffs_Object *obj)
 {
        if(obj && yaffs_SkipVerification(obj->myDev))
                return;
-               
+
        /* Verify sane equivalent object */
 }
 
@@ -722,7 +722,7 @@ static void yaffs_VerifySymlink(yaffs_Object *obj)
 {
        if(obj && yaffs_SkipVerification(obj->myDev))
                return;
-               
+
        /* Verify symlink string */
 }
 
@@ -735,32 +735,32 @@ static void yaffs_VerifySpecial(yaffs_Object *obj)
 static void yaffs_VerifyObject(yaffs_Object *obj)
 {
        yaffs_Device *dev;
-       
+
        __u32 chunkMin;
        __u32 chunkMax;
-       
+
        __u32 chunkIdOk;
        __u32 chunkIsLive;
-       
+
        if(!obj)
                return;
-       
+
        dev = obj->myDev;
-       
+
        if(yaffs_SkipVerification(dev))
                return;
-               
+
        /* Check sane object header chunk */
-       
+
        chunkMin = dev->internalStartBlock * dev->nChunksPerBlock;
        chunkMax = (dev->internalEndBlock+1) * dev->nChunksPerBlock - 1;
-       
+
        chunkIdOk = (obj->chunkId >= chunkMin && obj->chunkId <= chunkMax);
-       chunkIsLive = chunkIdOk && 
-                       yaffs_CheckChunkBit(dev, 
+       chunkIsLive = chunkIdOk &&
+                       yaffs_CheckChunkBit(dev,
                                            obj->chunkId / dev->nChunksPerBlock,
                                            obj->chunkId % dev->nChunksPerBlock);
-       if(!obj->fake && 
+       if(!obj->fake &&
            (!chunkIdOk || !chunkIsLive)) {
           T(YAFFS_TRACE_VERIFY,
           (TSTR("Obj %d has chunkId %d %s %s"TENDSTR),
@@ -768,36 +768,36 @@ static void yaffs_VerifyObject(yaffs_Object *obj)
           chunkIdOk ? "" : ",out of range",
           chunkIsLive || !chunkIdOk ? "" : ",marked as deleted"));
        }
-       
+
        if(chunkIdOk && chunkIsLive &&!yaffs_SkipNANDVerification(dev)) {
                yaffs_ExtendedTags tags;
                yaffs_ObjectHeader *oh;
                __u8 *buffer = yaffs_GetTempBuffer(dev,__LINE__);
-               
+
                oh = (yaffs_ObjectHeader *)buffer;
-               
+
                yaffs_ReadChunkWithTagsFromNAND(dev, obj->chunkId,buffer, &tags);
-               
+
                yaffs_VerifyObjectHeader(obj,oh,&tags,1);
-               
+
                yaffs_ReleaseTempBuffer(dev,buffer,__LINE__);
        }
-       
+
        /* Verify it has a parent */
        if(obj && !obj->fake &&
           (!obj->parent || obj->parent->myDev != dev)){
           T(YAFFS_TRACE_VERIFY,
           (TSTR("Obj %d has parent pointer %p which does not look like an object"TENDSTR),
-          obj->objectId,obj->parent));    
+          obj->objectId,obj->parent));
        }
-       
+
        /* Verify parent is a directory */
        if(obj->parent && obj->parent->variantType != YAFFS_OBJECT_TYPE_DIRECTORY){
           T(YAFFS_TRACE_VERIFY,
           (TSTR("Obj %d's parent is not a directory (type %d)"TENDSTR),
-          obj->objectId,obj->parent->variantType));       
+          obj->objectId,obj->parent->variantType));
        }
-       
+
        switch(obj->variantType){
        case YAFFS_OBJECT_TYPE_FILE:
                yaffs_VerifyFile(obj);
@@ -818,11 +818,11 @@ static void yaffs_VerifyObject(yaffs_Object *obj)
        default:
                T(YAFFS_TRACE_VERIFY,
                (TSTR("Obj %d has illegaltype %d"TENDSTR),
-               obj->objectId,obj->variantType));          
+               obj->objectId,obj->variantType));
                break;
        }
-       
-       
+
+
 }
 
 static void yaffs_VerifyObjects(yaffs_Device *dev)
@@ -833,9 +833,9 @@ static void yaffs_VerifyObjects(yaffs_Device *dev)
 
        if(yaffs_SkipVerification(dev))
                return;
-       
+
        /* Iterate through the objects in each hash entry */
-        
+
         for(i = 0; i <  YAFFS_NOBJECT_BUCKETS; i++){
                list_for_each(lh, &dev->objectBucket[i].list) {
                        if (lh) {
@@ -851,7 +851,7 @@ static void yaffs_VerifyObjects(yaffs_Device *dev)
 /*
  *  Simple hash function. Needs to have a reasonable spread
  */
+
 static Y_INLINE int yaffs_HashFunction(int n)
 {
        n = abs(n);
@@ -861,7 +861,7 @@ static Y_INLINE int yaffs_HashFunction(int n)
 /*
  * Access functions to useful fake objects
  */
+
 yaffs_Object *yaffs_Root(yaffs_Device * dev)
 {
        return dev->rootDir;
@@ -876,7 +876,7 @@ yaffs_Object *yaffs_LostNFound(yaffs_Device * dev)
 /*
  *  Erased NAND checking functions
  */
+
 int yaffs_CheckFF(__u8 * buffer, int nBytes)
 {
        /* Horrible, slow implementation */
@@ -898,10 +898,10 @@ static int yaffs_CheckChunkErased(struct yaffs_DeviceStruct *dev,
        int result;
 
        result = yaffs_ReadChunkWithTagsFromNAND(dev, chunkInNAND, data, &tags);
-       
+
        if(tags.eccResult > YAFFS_ECC_RESULT_NO_ERROR)
                retval = YAFFS_FAIL;
-               
+
 
        if (!yaffs_CheckFF(data, dev->nDataBytesPerChunk) || tags.chunkUsed) {
                T(YAFFS_TRACE_NANDACCESS,
@@ -1008,13 +1008,13 @@ static int yaffs_WriteNewChunkWithTagsToNAND(struct yaffs_DeviceStruct *dev,
 /*
  * Block retiring for handling a broken block.
  */
+
 static void yaffs_RetireBlock(yaffs_Device * dev, int blockInNAND)
 {
        yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, blockInNAND);
 
        yaffs_InvalidateCheckpoint(dev);
-       
+
        yaffs_MarkBlockBad(dev, blockInNAND);
 
        bi->blockState = YAFFS_BLOCK_STATE_DEAD;
@@ -1028,7 +1028,7 @@ static void yaffs_RetireBlock(yaffs_Device * dev, int blockInNAND)
  * Functions for robustisizing TODO
  *
  */
+
 static void yaffs_HandleWriteChunkOk(yaffs_Device * dev, int chunkInNAND,
                                     const __u8 * data,
                                     const yaffs_ExtendedTags * tags)
@@ -1046,13 +1046,13 @@ void yaffs_HandleChunkError(yaffs_Device *dev, yaffs_BlockInfo *bi)
                bi->gcPrioritise = 1;
                dev->hasPendingPrioritisedGCs = 1;
                bi->chunkErrorStrikes ++;
-               
+
                if(bi->chunkErrorStrikes > 3){
                        bi->needsRetiring = 1; /* Too many stikes, so retire this */
                        T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: Block struck out" TENDSTR)));
 
                }
-               
+
        }
 }
 
@@ -1063,23 +1063,23 @@ static void yaffs_HandleWriteChunkError(yaffs_Device * dev, int chunkInNAND, int
        yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, blockInNAND);
 
        yaffs_HandleChunkError(dev,bi);
-               
-       
+
+
        if(erasedOk ) {
                /* Was an actual write failure, so mark the block for retirement  */
                bi->needsRetiring = 1;
                T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS,
                  (TSTR("**>> Block %d needs retiring" TENDSTR), blockInNAND));
 
-               
+
        }
-       
+
        /* Delete the chunk */
        yaffs_DeleteChunk(dev, chunkInNAND, 1, __LINE__);
 }
 
 
-/*---------------- Name handling functions ------------*/ 
+/*---------------- Name handling functions ------------*/
 
 static __u16 yaffs_CalcNameSum(const YCHAR * name)
 {
@@ -1120,7 +1120,7 @@ static void yaffs_SetObjectName(yaffs_Object * obj, const YCHAR * name)
  * The list is hooked together using the first pointer
  * in the tnode.
  */
+
 /* yaffs_CreateTnodes creates a bunch more tnodes and
  * adds them to the tnode free list.
  * Don't use this function directly
@@ -1138,7 +1138,7 @@ 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;
@@ -1175,7 +1175,7 @@ static int yaffs_CreateTnodes(yaffs_Device * dev, int nTnodes)
                next = (yaffs_Tnode *) &mem[(i+1) * tnodeSize];
                curr->internal[0] = next;
        }
-       
+
        curr = (yaffs_Tnode *) &mem[(nTnodes - 1) * tnodeSize];
        curr->internal[0] = dev->freeTnodes;
        dev->freeTnodes = (yaffs_Tnode *)mem;
@@ -1190,7 +1190,7 @@ static int yaffs_CreateTnodes(yaffs_Device * dev, int nTnodes)
         * NB If we can't add this to the management list it isn't fatal
         * but it just means we can't free this bunch of tnodes later.
         */
-        
+
        tnl = YMALLOC(sizeof(yaffs_TnodeList));
        if (!tnl) {
                T(YAFFS_TRACE_ERROR,
@@ -1239,11 +1239,11 @@ static yaffs_Tnode *yaffs_GetTnodeRaw(yaffs_Device * dev)
 static yaffs_Tnode *yaffs_GetTnode(yaffs_Device * dev)
 {
        yaffs_Tnode *tn = yaffs_GetTnodeRaw(dev);
-       
+
        if(tn)
                memset(tn, 0, (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8);
 
-       return tn;      
+       return tn;
 }
 
 /* FreeTnode frees up a tnode and puts it back on the free list */
@@ -1299,19 +1299,19 @@ void yaffs_PutLevel0Tnode(yaffs_Device *dev, yaffs_Tnode *tn, unsigned pos, unsi
   __u32 bitInWord;
   __u32 wordInMap;
   __u32 mask;
-  
+
   pos &= YAFFS_TNODES_LEVEL0_MASK;
   val >>= dev->chunkGroupBits;
-  
+
   bitInMap = pos * dev->tnodeWidth;
   wordInMap = bitInMap /32;
   bitInWord = bitInMap & (32 -1);
-  
+
   mask = dev->tnodeMask << bitInWord;
-  
+
   map[wordInMap] &= ~mask;
   map[wordInMap] |= (mask & (val << bitInWord));
-  
+
   if(dev->tnodeWidth > (32-bitInWord)) {
     bitInWord = (32 - bitInWord);
     wordInMap++;;
@@ -1328,24 +1328,24 @@ static __u32 yaffs_GetChunkGroupBase(yaffs_Device *dev, yaffs_Tnode *tn, unsigne
   __u32 bitInWord;
   __u32 wordInMap;
   __u32 val;
-  
+
   pos &= YAFFS_TNODES_LEVEL0_MASK;
-  
+
   bitInMap = pos * dev->tnodeWidth;
   wordInMap = bitInMap /32;
   bitInWord = bitInMap & (32 -1);
-  
+
   val = map[wordInMap] >> bitInWord;
-  
+
   if(dev->tnodeWidth > (32-bitInWord)) {
     bitInWord = (32 - bitInWord);
     wordInMap++;;
     val |= (map[wordInMap] << bitInWord);
   }
-  
+
   val &= dev->tnodeMask;
   val <<= dev->chunkGroupBits;
-  
+
   return val;
 }
 
@@ -1394,7 +1394,7 @@ static yaffs_Tnode *yaffs_FindLevel0Tnode(yaffs_Device * dev,
        while (level > 0 && tn) {
                tn = tn->
                    internal[(chunkId >>
-                              ( YAFFS_TNODES_LEVEL0_BITS + 
+                              ( YAFFS_TNODES_LEVEL0_BITS +
                                 (level - 1) *
                                 YAFFS_TNODES_INTERNAL_BITS)
                              ) &
@@ -1416,7 +1416,7 @@ static yaffs_Tnode *yaffs_FindLevel0Tnode(yaffs_Device * dev,
  *  If the tn argument is NULL, then a fresh tnode will be added otherwise the specified tn will
  *  be plugged into the ttree.
  */
+
 static yaffs_Tnode *yaffs_AddOrFindLevel0Tnode(yaffs_Device * dev,
                                               yaffs_FileStructure * fStruct,
                                               __u32 chunkId,
@@ -1453,7 +1453,7 @@ static yaffs_Tnode *yaffs_AddOrFindLevel0Tnode(yaffs_Device * dev,
        if (requiredTallness > fStruct->topLevel) {
                /* Not tall enough,gotta make the tree taller */
                for (i = fStruct->topLevel; i < requiredTallness; i++) {
-               
+
                        tn = yaffs_GetTnode(dev);
 
                        if (tn) {
@@ -1472,7 +1472,7 @@ static yaffs_Tnode *yaffs_AddOrFindLevel0Tnode(yaffs_Device * dev,
 
        l = fStruct->topLevel;
        tn = fStruct->top;
-       
+
        if(l > 0) {
                while (l > 0 && tn) {
                        x = (chunkId >>
@@ -1492,13 +1492,13 @@ static yaffs_Tnode *yaffs_AddOrFindLevel0Tnode(yaffs_Device * dev,
                                        if(tn->internal[x])
                                                yaffs_FreeTnode(dev,tn->internal[x]);
                                        tn->internal[x] = passedTn;
-                       
+
                                } else if(!tn->internal[x]) {
                                        /* Don't have one, none passed in */
                                        tn->internal[x] = yaffs_GetTnode(dev);
                                }
                        }
-               
+
                        tn = tn->internal[x];
                        l--;
                }
@@ -1539,7 +1539,7 @@ static int yaffs_FindChunkInGroup(yaffs_Device * dev, int theChunk,
 
 /* DeleteWorker scans backwards through the tnode tree and deletes all the
  * chunks and tnodes in the file
- * Returns 1 if the tree was deleted. 
+ * Returns 1 if the tree was deleted.
  * Returns 0 if it stopped early due to hitting the limit and the delete is incomplete.
  */
 
@@ -1653,7 +1653,7 @@ static void yaffs_SoftDeleteChunk(yaffs_Device * dev, int chunk)
  * of the tnode.
  * Thus, essentially this is the same as DeleteWorker except that the chunks are soft deleted.
  */
+
 static int yaffs_SoftDeleteWorker(yaffs_Object * in, yaffs_Tnode * tn,
                                  __u32 level, int chunkOffset)
 {
@@ -1694,7 +1694,7 @@ static int yaffs_SoftDeleteWorker(yaffs_Object * in, yaffs_Tnode * tn,
                                theChunk = yaffs_GetChunkGroupBase(dev,tn,i);
                                if (theChunk) {
                                        /* Note this does not find the real chunk, only the chunk group.
-                                        * We make an assumption that a chunk group is not larger than 
+                                        * We make an assumption that a chunk group is not larger than
                                         * a block.
                                         */
                                        yaffs_SoftDeleteChunk(dev, theChunk);
@@ -1796,7 +1796,7 @@ static int yaffs_PruneFileStructure(yaffs_Device * dev,
                /* Now we have a tree with all the non-zero branches NULL but the height
                 * is the same as it was.
                 * Let's see if we can trim internal tnodes to shorten the tree.
-                * We can do this if only the 0th element in the tnode is in use 
+                * We can do this if only the 0th element in the tnode is in use
                 * (ie all the non-zero are NULL)
                 */
 
@@ -1850,7 +1850,7 @@ static int yaffs_CreateFreeObjects(yaffs_Device * dev, int nObjects)
                  (TSTR("yaffs: Could not allocate more objects" TENDSTR)));
                return YAFFS_FAIL;
        }
-       
+
        /* Hook them into the free list */
        for (i = 0; i < nObjects - 1; i++) {
                newObjects[i].siblings.next =
@@ -2132,7 +2132,7 @@ yaffs_Object *yaffs_CreateNewObject(yaffs_Device * dev, int number,
        theObject = yaffs_AllocateEmptyObject(dev);
        if(!theObject)
                return NULL;
-               
+
        if(type == YAFFS_OBJECT_TYPE_FILE){
                tn = yaffs_GetTnode(dev);
                if(!tn){
@@ -2140,8 +2140,8 @@ yaffs_Object *yaffs_CreateNewObject(yaffs_Device * dev, int number,
                        return NULL;
                }
        }
-               
-       
+
+
 
        if (theObject) {
                theObject->fake = 0;
@@ -2205,7 +2205,7 @@ static yaffs_Object *yaffs_FindOrCreateObjectByNumber(yaffs_Device * dev,
        return theObject;
 
 }
-                       
+
 
 static YCHAR *yaffs_CloneString(const YCHAR * str)
 {
@@ -2227,7 +2227,7 @@ static YCHAR *yaffs_CloneString(const YCHAR * str)
  * aliasString only has meaning for a sumlink.
  * rdev only has meaning for devices (a subset of special objects)
  */
+
 static yaffs_Object *yaffs_MknodObject(yaffs_ObjectType type,
                                       yaffs_Object * parent,
                                       const YCHAR * name,
@@ -2248,7 +2248,7 @@ static yaffs_Object *yaffs_MknodObject(yaffs_ObjectType type,
        }
 
        in = yaffs_CreateNewObject(dev, -1, type);
-       
+
        if(type == YAFFS_OBJECT_TYPE_SYMLINK){
                str = yaffs_CloneString(aliasString);
                if(!str){
@@ -2256,8 +2256,8 @@ static yaffs_Object *yaffs_MknodObject(yaffs_ObjectType type,
                        return NULL;
                }
        }
-       
-       
+
+
 
        if (in) {
                in->chunkId = -1;
@@ -2298,7 +2298,7 @@ static yaffs_Object *yaffs_MknodObject(yaffs_ObjectType type,
                            equivalentObject->objectId;
                        list_add(&in->hardLinks, &equivalentObject->hardLinks);
                        break;
-               case YAFFS_OBJECT_TYPE_FILE:    
+               case YAFFS_OBJECT_TYPE_FILE:
                case YAFFS_OBJECT_TYPE_DIRECTORY:
                case YAFFS_OBJECT_TYPE_SPECIAL:
                case YAFFS_OBJECT_TYPE_UNKNOWN:
@@ -2382,7 +2382,7 @@ static int yaffs_ChangeObjectName(yaffs_Object * obj, yaffs_Object * newDir,
                    TENDSTR)));
                YBUG();
        }
-       
+
        /* TODO: Do we need this different handling for YAFFS2 and YAFFS1?? */
        if (obj->myDev->isYaffs2) {
                unlinkOp = (newDir == obj->myDev->unlinkedDir);
@@ -2395,9 +2395,9 @@ static int yaffs_ChangeObjectName(yaffs_Object * obj, yaffs_Object * newDir,
 
        existingTarget = yaffs_FindObjectByName(newDir, newName);
 
-       /* If the object is a file going into the unlinked directory, 
+       /* If the object is a file going into the unlinked directory,
         *   then it is OK to just stuff it in since duplicate names are allowed.
-        *   else only proceed if the new name does not exist and if we're putting 
+        *   else only proceed if the new name does not exist and if we're putting
         *   it into a directory.
         */
        if ((unlinkOp ||
@@ -2461,7 +2461,7 @@ int yaffs_RenameObject(yaffs_Object * oldDir, const YCHAR * oldName,
                        /* There is a target that is a non-empty directory, so we fail */
                        return YAFFS_FAIL;      /* EEXIST or ENOTEMPTY */
                } else if (existingTarget && existingTarget != obj) {
-                       /* Nuke the target first, using shadowing, 
+                       /* Nuke the target first, using shadowing,
                         * but only if it isn't the same object
                         */
                        yaffs_ChangeObjectName(obj, newDir, newName, force,
@@ -2479,10 +2479,10 @@ int yaffs_RenameObject(yaffs_Object * oldDir, const YCHAR * oldName,
 static int yaffs_InitialiseBlocks(yaffs_Device * dev)
 {
        int nBlocks = dev->internalEndBlock - dev->internalStartBlock + 1;
-       
+
        dev->blockInfo = NULL;
        dev->chunkBits = NULL;
-       
+
        dev->allocationBlock = -1;      /* force it to get a new one */
 
        /* If the first allocation strategy fails, thry the alternate one */
@@ -2493,9 +2493,9 @@ static int yaffs_InitialiseBlocks(yaffs_Device * dev)
        }
        else
                dev->blockInfoAlt = 0;
-               
+
        if(dev->blockInfo){
-       
+
                /* Set up dynamic blockinfo stuff. */
                dev->chunkBitmapStride = (dev->nChunksPerBlock + 7) / 8; /* round up bytes */
                dev->chunkBits = YMALLOC(dev->chunkBitmapStride * nBlocks);
@@ -2506,7 +2506,7 @@ static int yaffs_InitialiseBlocks(yaffs_Device * dev)
                else
                        dev->chunkBitsAlt = 0;
        }
-       
+
        if (dev->blockInfo && dev->chunkBits) {
                memset(dev->blockInfo, 0, nBlocks * sizeof(yaffs_BlockInfo));
                memset(dev->chunkBits, 0, dev->chunkBitmapStride * nBlocks);
@@ -2527,7 +2527,7 @@ static void yaffs_DeinitialiseBlocks(yaffs_Device * dev)
        dev->blockInfoAlt = 0;
 
        dev->blockInfo = NULL;
-       
+
        if(dev->chunkBitsAlt && dev->chunkBits)
                YFREE_ALT(dev->chunkBits);
        else if(dev->chunkBits)
@@ -2591,14 +2591,14 @@ static int yaffs_FindBlockForGarbageCollection(yaffs_Device * dev,
        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++){
 
                        bi = yaffs_GetBlockInfo(dev, i);
                        //yaffs_VerifyBlock(dev,bi,i);
-                       
+
                        if(bi->gcPrioritise) {
                                pendingPrioritisedExist = 1;
                                if(bi->blockState == YAFFS_BLOCK_STATE_FULL &&
@@ -2610,7 +2610,7 @@ static int yaffs_FindBlockForGarbageCollection(yaffs_Device * dev,
                                }
                        }
                }
-               
+
                if(!pendingPrioritisedExist) /* None found, so we can clear this */
                        dev->hasPendingPrioritisedGCs = 0;
        }
@@ -2662,7 +2662,7 @@ static int yaffs_FindBlockForGarbageCollection(yaffs_Device * dev,
                        dirtiest = b;
                        pagesInUse = 0;
                }
-               else 
+               else
 #endif
 
                if (bi->blockState == YAFFS_BLOCK_STATE_FULL &&
@@ -2699,11 +2699,11 @@ static void yaffs_BlockBecameDirty(yaffs_Device * dev, int blockNo)
        /* If the block is still healthy erase it and mark as clean.
         * If the block has had a data failure, then retire it.
         */
-        
+
        T(YAFFS_TRACE_GC | YAFFS_TRACE_ERASE,
                (TSTR("yaffs_BlockBecameDirty block %d state %d %s"TENDSTR),
                blockNo, bi->blockState, (bi->needsRetiring) ? "needs retiring" : ""));
-               
+
        bi->blockState = YAFFS_BLOCK_STATE_DIRTY;
 
        if (!bi->needsRetiring) {
@@ -2716,7 +2716,7 @@ static void yaffs_BlockBecameDirty(yaffs_Device * dev, int blockNo)
                }
        }
 
-       if (erasedOk && 
+       if (erasedOk &&
            ((yaffs_traceMask & YAFFS_TRACE_ERASE) || !yaffs_SkipVerification(dev))) {
                int i;
                for (i = 0; i < dev->nChunksPerBlock; i++) {
@@ -2767,7 +2767,7 @@ static int yaffs_FindBlockForAllocation(yaffs_Device * dev)
 
                return -1;
        }
-       
+
        /* Find an empty block. */
 
        for (i = dev->internalStartBlock; i <= dev->internalEndBlock; i++) {
@@ -2808,13 +2808,13 @@ static int yaffs_CheckSpaceForAllocation(yaffs_Device * dev)
        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);
 }
 
@@ -2861,10 +2861,10 @@ static int yaffs_AllocateChunk(yaffs_Device * dev, int useReserve, yaffs_BlockIn
 
                if(blockUsedPtr)
                        *blockUsedPtr = bi;
-                       
+
                return retVal;
        }
-       
+
        T(YAFFS_TRACE_ERROR,
          (TSTR("!!!!!!!!! Allocator out !!!!!!!!!!!!!!!!!" TENDSTR)));
 
@@ -2907,7 +2907,7 @@ static int yaffs_GarbageCollectBlock(yaffs_Device * dev, int block)
        yaffs_Object *object;
 
        isCheckpointBlock = (bi->blockState == YAFFS_BLOCK_STATE_CHECKPOINT);
-       
+
        bi->blockState = YAFFS_BLOCK_STATE_COLLECTING;
 
        T(YAFFS_TRACE_TRACING,
@@ -2935,7 +2935,7 @@ static int yaffs_GarbageCollectBlock(yaffs_Device * dev, int block)
        } else {
 
                __u8 *buffer = yaffs_GetTempBuffer(dev, __LINE__);
-               
+
                yaffs_VerifyBlock(dev,bi,block);
 
                for (chunkInBlock = 0, oldChunk = block * dev->nChunksPerBlock;
@@ -2962,7 +2962,7 @@ static int yaffs_GarbageCollectBlock(yaffs_Device * dev, int block)
                                   ("Collecting page %d, %d %d %d " TENDSTR),
                                   chunkInBlock, tags.objectId, tags.chunkId,
                                   tags.byteCount));
-                                  
+
                                if(object && !yaffs_SkipVerification(dev)){
                                        if(tags.chunkId == 0)
                                                matchingChunk = object->chunkId;
@@ -2970,12 +2970,12 @@ static int yaffs_GarbageCollectBlock(yaffs_Device * dev, int block)
                                                matchingChunk = oldChunk; /* Defeat the test */
                                        else
                                                matchingChunk = yaffs_FindChunkInFile(object,tags.chunkId,NULL);
-                                       
+
                                        if(oldChunk != matchingChunk)
                                                T(YAFFS_TRACE_ERROR,
                                                  (TSTR("gc: page in gc mismatch: %d %d %d %d"TENDSTR),
                                                  oldChunk,matchingChunk,tags.objectId, tags.chunkId));
-                                               
+
                                }
 
                                if (!object) {
@@ -2990,7 +2990,7 @@ static int yaffs_GarbageCollectBlock(yaffs_Device * dev, int block)
                                    && tags.chunkId != 0) {
                                        /* Data chunk in a deleted file, throw it away
                                         * It's a soft deleted data chunk,
-                                        * No need to copy this, just forget about it and 
+                                        * No need to copy this, just forget about it and
                                         * fix up the object.
                                         */
 
@@ -3040,7 +3040,7 @@ static int yaffs_GarbageCollectBlock(yaffs_Device * dev, int block)
                                                oh->shadowsObject = -1;
                                                tags.extraShadows = 0;
                                                tags.extraIsShrinkHeader = 0;
-                                               
+
                                                yaffs_VerifyObjectHeader(object,oh,&tags,1);
                                        }
 
@@ -3099,7 +3099,7 @@ static int yaffs_GarbageCollectBlock(yaffs_Device * dev, int block)
        }
 
        yaffs_VerifyCollectedBlock(dev,bi,block);
-         
+
        if (chunksBefore >= (chunksAfter = yaffs_GetErasedChunks(dev))) {
                T(YAFFS_TRACE_GC,
                  (TSTR
@@ -3127,21 +3127,21 @@ static int yaffs_CheckGarbageCollection(yaffs_Device * dev)
        int aggressive;
        int gcOk = YAFFS_OK;
        int maxTries = 0;
-       
+
        int checkpointBlockAdjust;
 
        if (dev->isDoingGC) {
                /* 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.
         */
 
        do {
                maxTries++;
-               
+
                checkpointBlockAdjust = (dev->nCheckpointReservedBlocks - dev->blocksInCheckpoint);
                if(checkpointBlockAdjust < 0)
                        checkpointBlockAdjust = 0;
@@ -3326,11 +3326,11 @@ static int yaffs_CheckFileSanity(yaffs_Object * in)
 static int yaffs_PutChunkIntoFile(yaffs_Object * in, int chunkInInode,
                                  int chunkInNAND, int inScan)
 {
-       /* NB inScan is zero unless scanning. 
-        * For forward scanning, inScan is > 0; 
+       /* NB inScan is zero unless scanning.
+        * For forward scanning, inScan is > 0;
         * for backward scanning inScan is < 0
         */
-        
+
        yaffs_Tnode *tn;
        yaffs_Device *dev = in->myDev;
        int existingChunk;
@@ -3354,7 +3354,7 @@ static int yaffs_PutChunkIntoFile(yaffs_Object * in, int chunkInInode,
                return YAFFS_OK;
        }
 
-       tn = yaffs_AddOrFindLevel0Tnode(dev, 
+       tn = yaffs_AddOrFindLevel0Tnode(dev,
                                        &in->variant.fileVariant,
                                        chunkInInode,
                                        NULL);
@@ -3366,7 +3366,7 @@ static int yaffs_PutChunkIntoFile(yaffs_Object * in, int chunkInInode,
 
        if (inScan != 0) {
                /* If we're scanning then we need to test for duplicates
-                * NB This does not need to be efficient since it should only ever 
+                * NB This does not need to be efficient since it should only ever
                 * happen when the power fails during a write, then only one
                 * chunk should ever be affected.
                 *
@@ -3407,7 +3407,7 @@ static int yaffs_PutChunkIntoFile(yaffs_Object * in, int chunkInInode,
 
                        }
 
-                       /* NB The deleted flags should be false, otherwise the chunks will 
+                       /* NB The deleted flags should be false, otherwise the chunks will
                         * not be loaded during a scan
                         */
 
@@ -3418,7 +3418,7 @@ static int yaffs_PutChunkIntoFile(yaffs_Object * in, int chunkInInode,
                            (in->myDev->isYaffs2 ||
                             existingChunk <= 0 ||
                             ((existingSerial + 1) & 3) == newSerial)) {
-                               /* Forward scanning.                            
+                               /* Forward scanning.
                                 * Use new
                                 * Delete the old one and drop through to update the tnode
                                 */
@@ -3459,7 +3459,7 @@ static int yaffs_ReadChunkDataFromObject(yaffs_Object * in, int chunkInInode,
                  (TSTR("Chunk %d not found zero instead" TENDSTR),
                   chunkInNAND));
                /* get sane (zero) data if you read a hole */
-               memset(buffer, 0, in->myDev->nDataBytesPerChunk);       
+               memset(buffer, 0, in->myDev->nDataBytesPerChunk);
                return 0;
        }
 
@@ -3474,7 +3474,7 @@ void yaffs_DeleteChunk(yaffs_Device * dev, int chunkId, int markNAND, int lyn)
 
        if (chunkId <= 0)
                return;
-               
+
 
        dev->nDeletions++;
        block = chunkId / dev->nChunksPerBlock;
@@ -3602,7 +3602,7 @@ int yaffs_UpdateObjectHeader(yaffs_Object * in, const YCHAR * name, int force,
        YCHAR oldName[YAFFS_MAX_NAME_LENGTH + 1];
 
        yaffs_ObjectHeader *oh = NULL;
-       
+
        yaffs_strcpy(oldName,"silly old name");
 
        if (!in->fake || force) {
@@ -3618,9 +3618,9 @@ int yaffs_UpdateObjectHeader(yaffs_Object * in, const YCHAR * name, int force,
                if (prevChunkId >= 0) {
                        result = yaffs_ReadChunkWithTagsFromNAND(dev, prevChunkId,
                                                        buffer, &oldTags);
-                       
+
                        yaffs_VerifyObjectHeader(in,oh,&oldTags,0);
-                                                                               
+
                        memcpy(oldName, oh->name, sizeof(oh->name));
                }
 
@@ -3748,11 +3748,11 @@ int yaffs_UpdateObjectHeader(yaffs_Object * in, const YCHAR * name, int force,
 
 /*------------------------ Short Operations Cache ----------------------------------------
  *   In many situations where there is no high level buffering (eg WinCE) a lot of
- *   reads might be short sequential reads, and a lot of writes may be short 
+ *   reads might be short sequential reads, and a lot of writes may be short
  *   sequential writes. eg. scanning/writing a jpeg file.
- *   In these cases, a short read/write cache can provide a huge perfomance benefit 
+ *   In these cases, a short read/write cache can provide a huge perfomance benefit
  *   with dumb-as-a-rock code.
- *   In Linux, the page cache provides read buffering aand the short op cache provides write 
+ *   In Linux, the page cache provides read buffering aand the short op cache provides write
  *   buffering.
  *
  *   There are a limited number (~10) of cache chunks per device so that we don't
@@ -3765,14 +3765,14 @@ static int yaffs_ObjectHasCachedWriteData(yaffs_Object *obj)
        int i;
        yaffs_ChunkCache *cache;
        int nCaches = obj->myDev->nShortOpCaches;
-       
+
        for(i = 0; i < nCaches; i++){
                cache = &dev->srCache[i];
                if (cache->object == obj &&
                    cache->dirty)
                        return 1;
        }
-       
+
        return 0;
 }
 
@@ -3838,7 +3838,7 @@ void yaffs_FlushEntireDeviceCache(yaffs_Device *dev)
        yaffs_Object *obj;
        int nCaches = dev->nShortOpCaches;
        int i;
-       
+
        /* Find a dirty object in the cache and flush it...
         * until there are no further dirty objects.
         */
@@ -3848,18 +3848,18 @@ void yaffs_FlushEntireDeviceCache(yaffs_Device *dev)
                        if (dev->srCache[i].object &&
                            dev->srCache[i].dirty)
                                obj = dev->srCache[i].object;
-                           
+
                }
                if(obj)
                        yaffs_FlushFilesChunkCache(obj);
-                       
+
        } while(obj);
-       
+
 }
 
 
 /* Grab us a cache chunk for use.
- * First look for an empty one. 
+ * First look for an empty one.
  * Then look for the least recently used non-dirty one.
  * Then look for the least recently used dirty one...., flush and look again.
  */
@@ -3871,7 +3871,7 @@ static yaffs_ChunkCache *yaffs_GrabChunkCacheWorker(yaffs_Device * dev)
 
        if (dev->nShortOpCaches > 0) {
                for (i = 0; i < dev->nShortOpCaches; i++) {
-                       if (!dev->srCache[i].object) 
+                       if (!dev->srCache[i].object)
                                return &dev->srCache[i];
                }
 
@@ -4032,14 +4032,14 @@ static void yaffs_InvalidateWholeChunkCache(yaffs_Object * in)
 static int yaffs_WriteCheckpointValidityMarker(yaffs_Device *dev,int head)
 {
        yaffs_CheckpointValidity cp;
-       
+
        memset(&cp,0,sizeof(cp));
-       
+
        cp.structType = sizeof(cp);
        cp.magic = YAFFS_MAGIC;
        cp.version = YAFFS_CHECKPOINT_VERSION;
        cp.head = (head) ? 1 : 0;
-       
+
        return (yaffs_CheckpointWrite(dev,&cp,sizeof(cp)) == sizeof(cp))?
                1 : 0;
 }
@@ -4048,9 +4048,9 @@ static int yaffs_ReadCheckpointValidityMarker(yaffs_Device *dev, int head)
 {
        yaffs_CheckpointValidity cp;
        int ok;
-       
+
        ok = (yaffs_CheckpointRead(dev,&cp,sizeof(cp)) == sizeof(cp));
-       
+
        if(ok)
                ok = (cp.structType == sizeof(cp)) &&
                     (cp.magic == YAFFS_MAGIC) &&
@@ -4059,20 +4059,20 @@ static int yaffs_ReadCheckpointValidityMarker(yaffs_Device *dev, int head)
        return ok ? 1 : 0;
 }
 
-static void yaffs_DeviceToCheckpointDevice(yaffs_CheckpointDevice *cp, 
+static void yaffs_DeviceToCheckpointDevice(yaffs_CheckpointDevice *cp,
                                           yaffs_Device *dev)
 {
        cp->nErasedBlocks = dev->nErasedBlocks;
        cp->allocationBlock = dev->allocationBlock;
        cp->allocationPage = dev->allocationPage;
        cp->nFreeChunks = dev->nFreeChunks;
-       
+
        cp->nDeletedFiles = dev->nDeletedFiles;
        cp->nUnlinkedFiles = dev->nUnlinkedFiles;
        cp->nBackgroundDeletions = dev->nBackgroundDeletions;
        cp->sequenceNumber = dev->sequenceNumber;
        cp->oldestDirtySequence = dev->oldestDirtySequence;
-       
+
 }
 
 static void yaffs_CheckpointDeviceToDevice(yaffs_Device *dev,
@@ -4082,7 +4082,7 @@ static void yaffs_CheckpointDeviceToDevice(yaffs_Device *dev,
        dev->allocationBlock = cp->allocationBlock;
        dev->allocationPage = cp->allocationPage;
        dev->nFreeChunks = cp->nFreeChunks;
-       
+
        dev->nDeletedFiles = cp->nDeletedFiles;
        dev->nUnlinkedFiles = cp->nUnlinkedFiles;
        dev->nBackgroundDeletions = cp->nBackgroundDeletions;
@@ -4098,20 +4098,20 @@ static int yaffs_WriteCheckpointDevice(yaffs_Device *dev)
        __u32 nBlocks = (dev->internalEndBlock - dev->internalStartBlock + 1);
 
        int ok;
-               
+
        /* Write device runtime values*/
        yaffs_DeviceToCheckpointDevice(&cp,dev);
        cp.structType = sizeof(cp);
-       
+
        ok = (yaffs_CheckpointWrite(dev,&cp,sizeof(cp)) == sizeof(cp));
-       
+
        /* Write block info */
        if(ok) {
                nBytes = nBlocks * sizeof(yaffs_BlockInfo);
                ok = (yaffs_CheckpointWrite(dev,dev->blockInfo,nBytes) == nBytes);
        }
-               
-       /* Write chunk bits */          
+
+       /* Write chunk bits */
        if(ok) {
                nBytes = nBlocks * dev->chunkBitmapStride;
                ok = (yaffs_CheckpointWrite(dev,dev->chunkBits,nBytes) == nBytes);
@@ -4126,28 +4126,28 @@ static int yaffs_ReadCheckpointDevice(yaffs_Device *dev)
        __u32 nBytes;
        __u32 nBlocks = (dev->internalEndBlock - dev->internalStartBlock + 1);
 
-       int ok; 
-       
+       int ok;
+
        ok = (yaffs_CheckpointRead(dev,&cp,sizeof(cp)) == sizeof(cp));
        if(!ok)
                return 0;
-               
+
        if(cp.structType != sizeof(cp))
                return 0;
-               
-       
+
+
        yaffs_CheckpointDeviceToDevice(dev,&cp);
-       
+
        nBytes = nBlocks * sizeof(yaffs_BlockInfo);
-       
+
        ok = (yaffs_CheckpointRead(dev,dev->blockInfo,nBytes) == nBytes);
-       
+
        if(!ok)
                return 0;
        nBytes = nBlocks * dev->chunkBitmapStride;
-       
+
        ok = (yaffs_CheckpointRead(dev,dev->chunkBits,nBytes) == nBytes);
-       
+
        return ok ? 1 : 0;
 }
 
@@ -4158,7 +4158,7 @@ static void yaffs_ObjectToCheckpointObject(yaffs_CheckpointObject *cp,
        cp->objectId = obj->objectId;
        cp->parentId = (obj->parent) ? obj->parent->objectId : 0;
        cp->chunkId = obj->chunkId;
-       cp->variantType = obj->variantType;                     
+       cp->variantType = obj->variantType;
        cp->deleted = obj->deleted;
        cp->softDeleted = obj->softDeleted;
        cp->unlinked = obj->unlinked;
@@ -4167,7 +4167,7 @@ static void yaffs_ObjectToCheckpointObject(yaffs_CheckpointObject *cp,
        cp->unlinkAllowed = obj->unlinkAllowed;
        cp->serial = obj->serial;
        cp->nDataChunks = obj->nDataChunks;
-       
+
        if(obj->variantType == YAFFS_OBJECT_TYPE_FILE)
                cp->fileSizeOrEquivalentObjectId = obj->variant.fileVariant.fileSize;
        else if(obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK)
@@ -4178,9 +4178,9 @@ static void yaffs_CheckpointObjectToObject( yaffs_Object *obj,yaffs_CheckpointOb
 {
 
        yaffs_Object *parent;
-       
+
        obj->objectId = cp->objectId;
-       
+
        if(cp->parentId)
                parent = yaffs_FindOrCreateObjectByNumber(
                                        obj->myDev,
@@ -4188,12 +4188,12 @@ static void yaffs_CheckpointObjectToObject( yaffs_Object *obj,yaffs_CheckpointOb
                                        YAFFS_OBJECT_TYPE_DIRECTORY);
        else
                parent = NULL;
-               
+
        if(parent)
                yaffs_AddObjectToDirectory(parent, obj);
-               
+
        obj->chunkId = cp->chunkId;
-       obj->variantType = cp->variantType;                     
+       obj->variantType = cp->variantType;
        obj->deleted = cp->deleted;
        obj->softDeleted = cp->softDeleted;
        obj->unlinked = cp->unlinked;
@@ -4202,12 +4202,12 @@ static void yaffs_CheckpointObjectToObject( yaffs_Object *obj,yaffs_CheckpointOb
        obj->unlinkAllowed = cp->unlinkAllowed;
        obj->serial = cp->serial;
        obj->nDataChunks = cp->nDataChunks;
-       
+
        if(obj->variantType == YAFFS_OBJECT_TYPE_FILE)
                obj->variant.fileVariant.fileSize = cp->fileSizeOrEquivalentObjectId;
        else if(obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK)
                obj->variant.hardLinkVariant.equivalentObjectId = cp->fileSizeOrEquivalentObjectId;
-               
+
        if(obj->objectId >= YAFFS_NOBJECT_BUCKETS)
                obj->lazyLoaded = 1;
 }
@@ -4250,17 +4250,17 @@ static int yaffs_WriteCheckpointTnodes(yaffs_Object *obj)
 {
        __u32 endMarker = ~0;
        int ok = 1;
-       
+
        if(obj->variantType == YAFFS_OBJECT_TYPE_FILE){
                ok = yaffs_CheckpointTnodeWorker(obj,
                                            obj->variant.fileVariant.top,
                                            obj->variant.fileVariant.topLevel,
                                            0);
                if(ok)
-                       ok = (yaffs_CheckpointWrite(obj->myDev,&endMarker,sizeof(endMarker)) == 
+                       ok = (yaffs_CheckpointWrite(obj->myDev,&endMarker,sizeof(endMarker)) ==
                                sizeof(endMarker));
        }
-       
+
        return ok ? 1 : 0;
 }
 
@@ -4272,14 +4272,14 @@ static int yaffs_ReadCheckpointTnodes(yaffs_Object *obj)
        yaffs_FileStructure *fileStructPtr = &obj->variant.fileVariant;
        yaffs_Tnode *tn;
        int nread = 0;
-       
+
        ok = (yaffs_CheckpointRead(dev,&baseChunk,sizeof(baseChunk)) == sizeof(baseChunk));
-       
+
        while(ok && (~baseChunk)){
                nread++;
                /* Read level 0 tnode */
-               
-               
+
+
                /* printf("read  tnode at %d\n",baseChunk); */
                tn = yaffs_GetTnodeRaw(dev);
                if(tn)
@@ -4287,27 +4287,27 @@ static int yaffs_ReadCheckpointTnodes(yaffs_Object *obj)
                              (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8);
                else
                        ok = 0;
-                       
+
                if(tn && ok){
                        ok = yaffs_AddOrFindLevel0Tnode(dev,
                                                        fileStructPtr,
                                                        baseChunk,
                                                        tn) ? 1 : 0;
-                                                       
+
                }
-                       
+
                if(ok)
                        ok = (yaffs_CheckpointRead(dev,&baseChunk,sizeof(baseChunk)) == sizeof(baseChunk));
-               
+
        }
 
        T(YAFFS_TRACE_CHECKPOINT,(
                TSTR("Checkpoint read tnodes %d records, last %d. ok %d" TENDSTR),
                nread,baseChunk,ok));
 
-       return ok ? 1 : 0;      
+       return ok ? 1 : 0;
 }
+
 
 static int yaffs_WriteCheckpointObjects(yaffs_Device *dev)
 {
@@ -4317,11 +4317,11 @@ static int yaffs_WriteCheckpointObjects(yaffs_Device *dev)
        int ok = 1;
        struct list_head *lh;
 
-       
+
        /* Iterate through the objects in each hash entry,
         * dumping them to the checkpointing stream.
         */
-        
+
         for(i = 0; ok &&  i <  YAFFS_NOBJECT_BUCKETS; i++){
                list_for_each(lh, &dev->objectBucket[i].list) {
                        if (lh) {
@@ -4333,9 +4333,9 @@ static int yaffs_WriteCheckpointObjects(yaffs_Device *dev)
                                        T(YAFFS_TRACE_CHECKPOINT,(
                                                TSTR("Checkpoint write object %d parent %d type %d chunk %d obj addr %x" TENDSTR),
                                                cp.objectId,cp.parentId,cp.variantType,cp.chunkId,(unsigned) obj));
-                                               
+
                                        ok = (yaffs_CheckpointWrite(dev,&cp,sizeof(cp)) == sizeof(cp));
-                                       
+
                                        if(ok && obj->variantType == YAFFS_OBJECT_TYPE_FILE){
                                                ok = yaffs_WriteCheckpointTnodes(obj);
                                        }
@@ -4343,14 +4343,14 @@ static int yaffs_WriteCheckpointObjects(yaffs_Device *dev)
                        }
                }
         }
-        
+
         /* Dump end of list */
        memset(&cp,0xFF,sizeof(yaffs_CheckpointObject));
        cp.structType = sizeof(cp);
-       
+
        if(ok)
                ok = (yaffs_CheckpointWrite(dev,&cp,sizeof(cp)) == sizeof(cp));
-               
+
        return ok ? 1 : 0;
 }
 
@@ -4361,7 +4361,7 @@ static int yaffs_ReadCheckpointObjects(yaffs_Device *dev)
        int ok = 1;
        int done = 0;
        yaffs_Object *hardList = NULL;
-       
+
        while(ok && !done) {
                ok = (yaffs_CheckpointRead(dev,&cp,sizeof(cp)) == sizeof(cp));
                if(cp.structType != sizeof(cp)) {
@@ -4369,10 +4369,10 @@ static int yaffs_ReadCheckpointObjects(yaffs_Device *dev)
                                cp.structType,sizeof(cp),ok));
                        ok = 0;
                }
-                       
+
                T(YAFFS_TRACE_CHECKPOINT,(TSTR("Checkpoint read object %d parent %d type %d chunk %d " TENDSTR),
                        cp.objectId,cp.parentId,cp.variantType,cp.chunkId));
-                       
+
                if(ok && cp.objectId == ~0)
                        done = 1;
                else if(ok){
@@ -4387,14 +4387,14 @@ static int yaffs_ReadCheckpointObjects(yaffs_Device *dev)
                                                    hardList;
                                        hardList = obj;
                                }
-                          
+
                        }
                }
        }
-       
+
        if(ok)
                yaffs_HardlinkFixup(dev,hardList);
-       
+
        return ok ? 1 : 0;
 }
 
@@ -4402,14 +4402,14 @@ static int yaffs_WriteCheckpointSum(yaffs_Device *dev)
 {
        __u32 checkpointSum;
        int ok;
-       
+
        yaffs_GetCheckpointSum(dev,&checkpointSum);
-       
+
        ok = (yaffs_CheckpointWrite(dev,&checkpointSum,sizeof(checkpointSum)) == sizeof(checkpointSum));
-       
+
        if(!ok)
                return 0;
-       
+
        return 1;
 }
 
@@ -4418,17 +4418,17 @@ static int yaffs_ReadCheckpointSum(yaffs_Device *dev)
        __u32 checkpointSum0;
        __u32 checkpointSum1;
        int ok;
-       
+
        yaffs_GetCheckpointSum(dev,&checkpointSum0);
-       
+
        ok = (yaffs_CheckpointRead(dev,&checkpointSum1,sizeof(checkpointSum1)) == sizeof(checkpointSum1));
-       
+
        if(!ok)
                return 0;
-               
+
        if(checkpointSum0 != checkpointSum1)
                return 0;
-       
+
        return 1;
 }
 
@@ -4437,15 +4437,15 @@ static int yaffs_WriteCheckpointData(yaffs_Device *dev)
 {
 
        int ok = 1;
-       
+
        if(dev->skipCheckpointWrite || !dev->isYaffs2){
                T(YAFFS_TRACE_CHECKPOINT,(TSTR("skipping checkpoint write" TENDSTR)));
                ok = 0;
        }
-               
+
        if(ok)
                ok = yaffs_CheckpointOpen(dev,1);
-       
+
        if(ok){
                T(YAFFS_TRACE_CHECKPOINT,(TSTR("write checkpoint validity" TENDSTR)));
                ok = yaffs_WriteCheckpointValidityMarker(dev,1);
@@ -4462,18 +4462,18 @@ static int yaffs_WriteCheckpointData(yaffs_Device *dev)
                T(YAFFS_TRACE_CHECKPOINT,(TSTR("write checkpoint validity" TENDSTR)));
                ok = yaffs_WriteCheckpointValidityMarker(dev,0);
        }
-       
+
        if(ok){
                ok = yaffs_WriteCheckpointSum(dev);
        }
-       
-       
+
+
        if(!yaffs_CheckpointClose(dev))
                 ok = 0;
-                
+
        if(ok)
                dev->isCheckpointed = 1;
-        else 
+        else
                dev->isCheckpointed = 0;
 
        return dev->isCheckpointed;
@@ -4482,17 +4482,17 @@ static int yaffs_WriteCheckpointData(yaffs_Device *dev)
 static int yaffs_ReadCheckpointData(yaffs_Device *dev)
 {
        int ok = 1;
-       
+
        if(dev->skipCheckpointRead || !dev->isYaffs2){
                T(YAFFS_TRACE_CHECKPOINT,(TSTR("skipping checkpoint read" TENDSTR)));
                ok = 0;
        }
-       
+
        if(ok)
                ok = yaffs_CheckpointOpen(dev,0); /* open for read */
-       
+
        if(ok){
-               T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint validity" TENDSTR)));   
+               T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint validity" TENDSTR)));
                ok = yaffs_ReadCheckpointValidityMarker(dev,1);
        }
        if(ok){
@@ -4500,14 +4500,14 @@ static int yaffs_ReadCheckpointData(yaffs_Device *dev)
                ok = yaffs_ReadCheckpointDevice(dev);
        }
        if(ok){
-               T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint objects" TENDSTR)));    
+               T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint objects" TENDSTR)));
                ok = yaffs_ReadCheckpointObjects(dev);
        }
        if(ok){
                T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint validity" TENDSTR)));
                ok = yaffs_ReadCheckpointValidityMarker(dev,0);
        }
-       
+
        if(ok){
                ok = yaffs_ReadCheckpointSum(dev);
                T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint checksum %d" TENDSTR),ok));
@@ -4518,7 +4518,7 @@ static int yaffs_ReadCheckpointData(yaffs_Device *dev)
 
        if(ok)
                dev->isCheckpointed = 1;
-        else 
+        else
                dev->isCheckpointed = 0;
 
        return ok ? 1 : 0;
@@ -4527,7 +4527,7 @@ static int yaffs_ReadCheckpointData(yaffs_Device *dev)
 
 static void yaffs_InvalidateCheckpoint(yaffs_Device *dev)
 {
-       if(dev->isCheckpointed || 
+       if(dev->isCheckpointed ||
           dev->blocksInCheckpoint > 0){
                dev->isCheckpointed = 0;
                yaffs_CheckpointInvalidateStream(dev);
@@ -4550,7 +4550,7 @@ int yaffs_CheckpointSave(yaffs_Device *dev)
                yaffs_InvalidateCheckpoint(dev);
                yaffs_WriteCheckpointData(dev);
        }
-       
+
        T(YAFFS_TRACE_ALWAYS,(TSTR("save exit: isCheckpointed %d"TENDSTR),dev->isCheckpointed));
 
        return dev->isCheckpointed;
@@ -4560,7 +4560,7 @@ int yaffs_CheckpointRestore(yaffs_Device *dev)
 {
        int retval;
        T(YAFFS_TRACE_CHECKPOINT,(TSTR("restore entry: isCheckpointed %d"TENDSTR),dev->isCheckpointed));
-               
+
        retval = yaffs_ReadCheckpointData(dev);
 
        if(dev->isCheckpointed){
@@ -4570,7 +4570,7 @@ int yaffs_CheckpointRestore(yaffs_Device *dev)
        }
 
        T(YAFFS_TRACE_CHECKPOINT,(TSTR("restore exit: isCheckpointed %d"TENDSTR),dev->isCheckpointed));
-       
+
        return retval;
 }
 
@@ -4606,7 +4606,7 @@ int yaffs_ReadDataFromFile(yaffs_Object * in, __u8 * buffer, loff_t offset,
                chunk++;
 
                /* OK now check for the curveball where the start and end are in
-                * the same chunk.      
+                * the same chunk.
                 */
                if ((start + n) < dev->nDataBytesPerChunk) {
                        nToCopy = n;
@@ -4763,7 +4763,7 @@ int yaffs_WriteDataToFile(yaffs_Object * in, const __u8 * buffer, loff_t offset,
                                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)) {
@@ -4776,12 +4776,12 @@ int yaffs_WriteDataToFile(yaffs_Object * in, const __u8 * buffer, loff_t offset,
                                                                      cache->
                                                                      data);
                                }
-                               else if(cache && 
+                               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;
                                }
 
@@ -4945,7 +4945,7 @@ int yaffs_ResizeFile(yaffs_Object * in, loff_t newSize)
        int oldFileSize = in->variant.fileVariant.fileSize;
        int newSizeOfPartialChunk;
        int newFullChunks;
-       
+
        yaffs_Device *dev = in->myDev;
 
        yaffs_AddrToChunk(dev, newSize, &newFullChunks, &newSizeOfPartialChunk);
@@ -4969,7 +4969,7 @@ int yaffs_ResizeFile(yaffs_Object * in, loff_t newSize)
 
                if (newSizeOfPartialChunk != 0) {
                        int lastChunk = 1 + newFullChunks;
-                       
+
                        __u8 *localBuffer = yaffs_GetTempBuffer(dev, __LINE__);
 
                        /* Got to read and rewrite the last chunk with its new size and zero pad */
@@ -4993,8 +4993,8 @@ int yaffs_ResizeFile(yaffs_Object * in, loff_t newSize)
                in->variant.fileVariant.fileSize = newSize;
        }
 
-               
-       
+
+
        /* Write a new object header.
         * show we've shrunk the file, if need be
         * Do this only if the file is not in the deleted directories.
@@ -5313,7 +5313,7 @@ static void yaffs_HardlinkFixup(yaffs_Device *dev, yaffs_Object *hardList)
 {
        yaffs_Object *hl;
        yaffs_Object *in;
-       
+
        while (hardList) {
                hl = hardList;
                hardList = (yaffs_Object *) (hardList->hardLinks.next);
@@ -5376,9 +5376,9 @@ static int yaffs_Scan(yaffs_Device * dev)
        yaffs_Object *in;
        yaffs_Object *parent;
        int nBlocks = dev->internalEndBlock - dev->internalStartBlock + 1;
-       
+
        int alloc_failed = 0;
-       
+
 
        __u8 *chunkData;
 
@@ -5389,9 +5389,9 @@ static int yaffs_Scan(yaffs_Device * dev)
                  (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));
@@ -5520,7 +5520,7 @@ static int yaffs_Scan(yaffs_Device * dev)
                                /*T((" %d %d deleted\n",blk,c)); */
                        } else if (!tags.chunkUsed) {
                                /* An unassigned chunk in the block
-                                * This means that either the block is empty or 
+                                * This means that either the block is empty or
                                 * this is the one being allocated from
                                 */
 
@@ -5537,9 +5537,9 @@ static int yaffs_Scan(yaffs_Device * dev)
                                        state = YAFFS_BLOCK_STATE_ALLOCATING;
                                        dev->allocationBlock = blk;
                                        dev->allocationPage = c;
-                                       dev->allocationBlockFinder = blk;       
+                                       dev->allocationBlockFinder = blk;
                                        /* Set it to here to encourage the allocator to go forth from here. */
-                                       
+
                                        /* Yaffs2 sanity check:
                                         * This should be the one with the highest sequence number
                                         */
@@ -5569,7 +5569,7 @@ static int yaffs_Scan(yaffs_Device * dev)
                                /* PutChunkIntoFile checks for a clash (two data chunks with
                                 * the same chunkId).
                                 */
-                                
+
                                if(!in)
                                        alloc_failed = 1;
 
@@ -5577,11 +5577,11 @@ static int yaffs_Scan(yaffs_Device * dev)
                                        if(!yaffs_PutChunkIntoFile(in, tags.chunkId, chunk,1))
                                                alloc_failed = 1;
                                }
-                               
+
                                endpos =
                                    (tags.chunkId - 1) * dev->nDataBytesPerChunk +
                                    tags.byteCount;
-                               if (in && 
+                               if (in &&
                                    in->variantType == YAFFS_OBJECT_TYPE_FILE
                                    && in->variant.fileVariant.scannedFileSize <
                                    endpos) {
@@ -5613,7 +5613,7 @@ static int yaffs_Scan(yaffs_Device * dev)
                                                              tags.objectId);
                                if (in && in->variantType != oh->type) {
                                        /* This should not happen, but somehow
-                                        * Wev'e ended up with an objectId that has been reused but not yet 
+                                        * Wev'e ended up with an objectId that has been reused but not yet
                                         * deleted, and worse still it has changed type. Delete the old object.
                                         */
 
@@ -5629,7 +5629,7 @@ static int yaffs_Scan(yaffs_Device * dev)
 
                                if(!in)
                                        alloc_failed = 1;
-                                       
+
                                if (in && oh->shadowsObject > 0) {
                                        yaffs_HandleShadowedObject(dev,
                                                                   oh->
@@ -5752,11 +5752,11 @@ static int yaffs_Scan(yaffs_Device * dev)
                                         * Since we might scan a hardlink before its equivalent object is scanned
                                         * we put them all in a list.
                                         * After scanning is complete, we should have all the objects, so we run through this
-                                        * list and fix up all the chains.              
+                                        * list and fix up all the chains.
                                         */
 
                                        switch (in->variantType) {
-                                       case YAFFS_OBJECT_TYPE_UNKNOWN: 
+                                       case YAFFS_OBJECT_TYPE_UNKNOWN:
                                                /* Todo got a problem */
                                                break;
                                        case YAFFS_OBJECT_TYPE_FILE:
@@ -5791,7 +5791,7 @@ static int yaffs_Scan(yaffs_Device * dev)
                                        case YAFFS_OBJECT_TYPE_SPECIAL:
                                                /* Do nothing */
                                                break;
-                                       case YAFFS_OBJECT_TYPE_SYMLINK: 
+                                       case YAFFS_OBJECT_TYPE_SYMLINK:
                                                in->variant.symLinkVariant.alias =
                                                    yaffs_CloneString(oh->alias);
                                                if(!in->variant.symLinkVariant.alias)
@@ -5826,11 +5826,11 @@ static int yaffs_Scan(yaffs_Device * dev)
        if (blockIndex) {
                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 
+        * We should now have scanned all the objects, now it's time to add these
         * hardlinks.
         */
 
@@ -5860,9 +5860,9 @@ static int yaffs_Scan(yaffs_Device * dev)
        if(alloc_failed){
                return YAFFS_FAIL;
        }
-       
+
        T(YAFFS_TRACE_SCAN, (TSTR("yaffs_Scan ends" TENDSTR)));
-       
+
 
        return YAFFS_OK;
 }
@@ -5878,7 +5878,7 @@ static void yaffs_CheckObjectDetailsLoaded(yaffs_Object *in)
 
        if(!in)
                return;
-               
+
 #if 0
        T(YAFFS_TRACE_SCAN,(TSTR("details for object %d %s loaded" TENDSTR),
                in->objectId,
@@ -5890,7 +5890,7 @@ static void yaffs_CheckObjectDetailsLoaded(yaffs_Object *in)
                chunkData = yaffs_GetTempBuffer(dev, __LINE__);
 
                result = yaffs_ReadChunkWithTagsFromNAND(dev,in->chunkId,chunkData,&tags);
-               oh = (yaffs_ObjectHeader *) chunkData;          
+               oh = (yaffs_ObjectHeader *) chunkData;
 
                in->yst_mode = oh->yst_mode;
 #ifdef CONFIG_YAFFS_WINCE
@@ -5907,17 +5907,17 @@ static void yaffs_CheckObjectDetailsLoaded(yaffs_Object *in)
                in->yst_mtime = oh->yst_mtime;
                in->yst_ctime = oh->yst_ctime;
                in->yst_rdev = oh->yst_rdev;
-               
+
 #endif
                yaffs_SetObjectName(in, oh->name);
-               
+
                if(in->variantType == YAFFS_OBJECT_TYPE_SYMLINK){
                         in->variant.symLinkVariant.alias =
                                                    yaffs_CloneString(oh->alias);
                        if(!in->variant.symLinkVariant.alias)
                                alloc_failed = 1; /* Not returned to caller */
                }
-                                                   
+
                yaffs_ReleaseTempBuffer(dev,chunkData, __LINE__);
        }
 }
@@ -5945,13 +5945,13 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
        int nBlocks = dev->internalEndBlock - dev->internalStartBlock + 1;
        int itsUnlinked;
        __u8 *chunkData;
-       
+
        int fileSize;
        int isShrink;
        int foundChunksInBlock;
        int equivalentObjectId;
        int alloc_failed = 0;
-       
+
 
        yaffs_BlockIndex *blockIndex = NULL;
        int altBlockIndex = 0;
@@ -5971,20 +5971,20 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
        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;
        }
-       
+
        dev->blocksInCheckpoint = 0;
-       
+
        chunkData = yaffs_GetTempBuffer(dev, __LINE__);
 
        /* Scan all the blocks to determine their state */
@@ -6001,15 +6001,15 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
 
                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_CHECKPOINT){
                        dev->blocksInCheckpoint++;
-                       
+
                } else if (state == YAFFS_BLOCK_STATE_DEAD) {
                        T(YAFFS_TRACE_BAD_BLOCKS,
                          (TSTR("block %d is bad" TENDSTR), blk));
@@ -6058,7 +6058,7 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
 #else
        {
                /* Dungy old bubble sort... */
-               
+
                yaffs_BlockIndex temp;
                int i;
                int j;
@@ -6094,22 +6094,22 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
                blk = blockIndex[blockIterator].block;
 
                bi = yaffs_GetBlockInfo(dev, blk);
-               
-               
+
+
                state = bi->blockState;
 
                deleted = 0;
 
                /* For each chunk in each block that needs scanning.... */
                foundChunksInBlock = 0;
-               for (c = dev->nChunksPerBlock - 1; 
+               for (c = dev->nChunksPerBlock - 1;
                     !alloc_failed && c >= 0 &&
                     (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING ||
                      state == YAFFS_BLOCK_STATE_ALLOCATING); c--) {
-                       /* Scan backwards... 
+                       /* Scan backwards...
                         * Read the tags and decide what to do
                         */
-                       
+
                        chunk = blk * dev->nChunksPerBlock + c;
 
                        result = yaffs_ReadChunkWithTagsFromNAND(dev, chunk, NULL,
@@ -6123,14 +6123,14 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
                                 * 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 
+                                * chunk and his means that either the block is empty or
                                 * this is the one being allocated from
                                 */
 
                                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;
@@ -6140,7 +6140,7 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
                                            state == YAFFS_BLOCK_STATE_ALLOCATING) {
                                                if(dev->sequenceNumber == bi->sequenceNumber) {
                                                        /* this is the block being allocated from */
-                                               
+
                                                        T(YAFFS_TRACE_SCAN,
                                                          (TSTR
                                                           (" Allocating from %d %d"
@@ -6149,34 +6149,34 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
                                                        state = YAFFS_BLOCK_STATE_ALLOCATING;
                                                        dev->allocationBlock = blk;
                                                        dev->allocationPage = c;
-                                                       dev->allocationBlockFinder = blk;       
+                                                       dev->allocationBlockFinder = blk;
                                                }
                                                else {
                                                        /* This is a partially written block that is not
                                                         * the current allocation block. This block must have
                                                         * had a write failure, so set up for retirement.
                                                         */
-                                                 
+
                                                         bi->needsRetiring = 1;
                                                         bi->gcPrioritise = 1;
-                                                                                                        
+
                                                         T(YAFFS_TRACE_ALWAYS,
                                                         (TSTR("Partially written block %d being set for retirement" TENDSTR),
                                                         blk));
                                                }
 
                                        }
-                                        
+
                                }
 
                                dev->nFreeChunks++;
-                               
+
                        } else if (tags.chunkId > 0) {
                                /* chunkId > 0 so it is a data chunk... */
                                unsigned int endpos;
                                __u32 chunkBase =
                                    (tags.chunkId - 1) * dev->nDataBytesPerChunk;
-                                                               
+
                                foundChunksInBlock = 1;
 
 
@@ -6191,7 +6191,7 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
                                        /* Out of memory */
                                        alloc_failed = 1;
                                }
-                               
+
                                if (in &&
                                    in->variantType == YAFFS_OBJECT_TYPE_FILE
                                    && chunkBase <
@@ -6202,14 +6202,14 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
                                                alloc_failed = 1;
                                        }
 
-                                       /* File size is calculated by looking at the data chunks if we have not 
+                                       /* 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;
-                                           
+
                                        if (!in->valid &&       /* have not got an object header yet */
                                            in->variant.fileVariant.
                                            scannedFileSize < endpos) {
@@ -6255,7 +6255,7 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
                                    ) {
 
                                        /* If we don't have  valid info then we need to read the chunk
-                                        * TODO In future we can probably defer reading the chunk and 
+                                        * TODO In future we can probably defer reading the chunk and
                                         * living with invalid data until needed.
                                         */
 
@@ -6283,12 +6283,12 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
 
                                if (in->valid) {
                                        /* We have already filled this one.
-                                        * We have a duplicate that will be discarded, but 
+                                        * We have a duplicate that will be discarded, but
                                         * we first have to suck out resize info if it is a file.
                                         */
 
-                                       if ((in->variantType == YAFFS_OBJECT_TYPE_FILE) && 
-                                            ((oh && 
+                                       if ((in->variantType == YAFFS_OBJECT_TYPE_FILE) &&
+                                            ((oh &&
                                               oh-> type == YAFFS_OBJECT_TYPE_FILE)||
                                              (tags.extraHeaderInfoAvailable  &&
                                               tags.extraObjectType == YAFFS_OBJECT_TYPE_FILE))
@@ -6339,7 +6339,7 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
                                     YAFFS_OBJECTID_LOSTNFOUND)) {
                                        /* We only load some info, don't fiddle with directory structure */
                                        in->valid = 1;
-                                       
+
                                        if(oh) {
                                                in->variantType = oh->type;
 
@@ -6358,13 +6358,13 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
                                                in->yst_mtime = oh->yst_mtime;
                                                in->yst_ctime = oh->yst_ctime;
                                                in->yst_rdev = oh->yst_rdev;
-               
+
 #endif
                                        } else {
                                                in->variantType = tags.extraObjectType;
                                                in->lazyLoaded = 1;
                                        }
-                                               
+
                                        in->chunkId = chunk;
 
                                } else if (!in->valid) {
@@ -6372,7 +6372,7 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
 
                                        in->valid = 1;
                                        in->chunkId = chunk;
-                                       
+
                                        if(oh) {
                                                in->variantType = oh->type;
 
@@ -6393,12 +6393,12 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
                                                in->yst_rdev = oh->yst_rdev;
 #endif
 
-                                               if (oh->shadowsObject > 0) 
+                                               if (oh->shadowsObject > 0)
                                                        yaffs_HandleShadowedObject(dev,
                                                                           oh->
                                                                           shadowsObject,
                                                                           1);
-                                       
+
 
                                                yaffs_SetObjectName(in, oh->name);
                                                parent =
@@ -6466,11 +6466,11 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
                                         * Since we might scan a hardlink before its equivalent object is scanned
                                         * we put them all in a list.
                                         * After scanning is complete, we should have all the objects, so we run
-                                        * through this list and fix up all the chains.              
+                                        * through this list and fix up all the chains.
                                         */
 
                                        switch (in->variantType) {
-                                       case YAFFS_OBJECT_TYPE_UNKNOWN: 
+                                       case YAFFS_OBJECT_TYPE_UNKNOWN:
                                                /* Todo got a problem */
                                                break;
                                        case YAFFS_OBJECT_TYPE_FILE:
@@ -6479,7 +6479,7 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
                                                    scannedFileSize < fileSize) {
                                                        /* This covers the case where the file size is greater
                                                         * than where the data is
-                                                        * This will happen if the file is resized to be larger 
+                                                        * This will happen if the file is resized to be larger
                                                         * than its current data extents.
                                                         */
                                                        in->variant.fileVariant.fileSize = fileSize;
@@ -6520,7 +6520,7 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
                                        }
 
                                }
-                               
+
                        }
 
                } /* End of scanning for each chunk */
@@ -6541,19 +6541,19 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
 
        }
 
-       if (altBlockIndex) 
+       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 
+        * We should now have scanned all the objects, now it's time to add these
         * hardlinks.
         */
        yaffs_HardlinkFixup(dev,hardList);
-       
-       
+
+
        /*
        *  Sort out state of unlinked and deleted objects.
        */
@@ -6586,7 +6586,7 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
        }
 
        yaffs_ReleaseTempBuffer(dev, chunkData, __LINE__);
-       
+
        if(alloc_failed){
                return YAFFS_FAIL;
        }
@@ -6601,10 +6601,10 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
 static void yaffs_RemoveObjectFromDirectory(yaffs_Object * obj)
 {
        yaffs_Device *dev = obj->myDev;
-       
+
        if(dev && dev->removeObjectCallback)
                dev->removeObjectCallback(obj);
-          
+
        list_del_init(&obj->siblings);
        obj->parent = NULL;
 }
@@ -6682,7 +6682,7 @@ yaffs_Object *yaffs_FindObjectByName(yaffs_Object * directory,
        list_for_each(i, &directory->variant.directoryVariant.children) {
                if (i) {
                        l = list_entry(i, yaffs_Object, siblings);
-                       
+
                        yaffs_CheckObjectDetailsLoaded(l);
 
                        /* Special case for lost-n-found */
@@ -6690,7 +6690,7 @@ yaffs_Object *yaffs_FindObjectByName(yaffs_Object * directory,
                                if (yaffs_strcmp(name, YAFFS_LOSTNFOUND_NAME) == 0) {
                                        return l;
                                }
-                       } else if (yaffs_SumCompare(l->sum, sum) || l->chunkId <= 0)    
+                       } else if (yaffs_SumCompare(l->sum, sum) || l->chunkId <= 0)
                        {
                                /* LostnFound cunk called Objxxx
                                 * Do a real check
@@ -6762,7 +6762,7 @@ yaffs_Object *yaffs_GetEquivalentObject(yaffs_Object * obj)
 int yaffs_GetObjectName(yaffs_Object * obj, YCHAR * name, int buffSize)
 {
        memset(name, 0, buffSize * sizeof(YCHAR));
-       
+
        yaffs_CheckObjectDetailsLoaded(obj);
 
        if (obj->objectId == YAFFS_OBJECTID_LOSTNFOUND) {
@@ -6994,13 +6994,13 @@ static int yaffs_CheckDevFunctions(const yaffs_Device * dev)
 static int yaffs_CreateInitialDirectories(yaffs_Device *dev)
 {
        /* Initialise the unlinked, deleted, root and lost and found directories */
-       
+
        dev->lostNFoundDir = dev->rootDir =  NULL;
        dev->unlinkedDir = dev->deletedDir = NULL;
 
        dev->unlinkedDir =
            yaffs_CreateFakeDirectory(dev, YAFFS_OBJECTID_UNLINKED, S_IFDIR);
-       
+
        dev->deletedDir =
            yaffs_CreateFakeDirectory(dev, YAFFS_OBJECTID_DELETED, S_IFDIR);
 
@@ -7010,12 +7010,12 @@ static int yaffs_CreateInitialDirectories(yaffs_Device *dev)
        dev->lostNFoundDir =
            yaffs_CreateFakeDirectory(dev, YAFFS_OBJECTID_LOSTNFOUND,
                                      YAFFS_LOSTNFOUND_MODE | S_IFDIR);
-       
+
        if(dev->lostNFoundDir && dev->rootDir && dev->unlinkedDir && dev->deletedDir){
                yaffs_AddObjectToDirectory(dev->rootDir, dev->lostNFoundDir);
                return YAFFS_OK;
        }
-       
+
        return YAFFS_FAIL;
 }
 
@@ -7049,12 +7049,12 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
 
        /* Check geometry parameters. */
 
-       if ((dev->isYaffs2 && dev->nDataBytesPerChunk < 1024) || 
-           (!dev->isYaffs2 && dev->nDataBytesPerChunk != 512) || 
-            dev->nChunksPerBlock < 2 || 
-            dev->nReservedBlocks < 2 || 
-            dev->internalStartBlock <= 0 || 
-            dev->internalEndBlock <= 0 || 
+       if ((dev->isYaffs2 && dev->nDataBytesPerChunk < 1024) ||
+           (!dev->isYaffs2 && dev->nDataBytesPerChunk != 512) ||
+            dev->nChunksPerBlock < 2 ||
+            dev->nReservedBlocks < 2 ||
+            dev->internalStartBlock <= 0 ||
+            dev->internalEndBlock <= 0 ||
             dev->internalEndBlock <= (dev->internalStartBlock + dev->nReservedBlocks + 2)      // otherwise it is too small
            ) {
                T(YAFFS_TRACE_ALWAYS,
@@ -7100,9 +7100,9 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
 
 
        /* OK now calculate a few things for the device */
-       
+
        /*
-        *  Calculate all the chunk size manipulation numbers: 
+        *  Calculate all the chunk size manipulation numbers:
         */
         /* Start off assuming it is a power of 2 */
         dev->chunkShift = ShiftDiv(dev->nDataBytesPerChunk);
@@ -7121,7 +7121,7 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
                dev->chunkShift = 0;
                dev->chunkMask = 0;
        }
-               
+
 
        /*
         * Calculate chunkGroupBits.
@@ -7129,9 +7129,9 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
         */
 
        x = dev->nChunksPerBlock * (dev->internalEndBlock + 1);
-       
+
        bits = ShiftsGE(x);
-       
+
        /* Set up tnode width if wide tnodes are enabled. */
        if(!dev->wideTnodesDisabled){
                /* bits must be even so that we end up with 32-bit words */
@@ -7144,20 +7144,20 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
        }
        else
                dev->tnodeWidth = 16;
+
        dev->tnodeMask = (1<<dev->tnodeWidth)-1;
-               
+
        /* Level0 Tnodes are 16 bits or wider (if wide tnodes are enabled),
         * so if the bitwidth of the
         * chunk range we're using is greater than 16 we need
         * to figure out chunk shift and chunkGroupSize
         */
-                
+
        if (bits <= dev->tnodeWidth)
                dev->chunkGroupBits = 0;
        else
                dev->chunkGroupBits = bits - dev->tnodeWidth;
-               
+
 
        dev->chunkGroupSize = 1 << dev->chunkGroupBits;
 
@@ -7195,11 +7195,11 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
        /* Initialise temporary buffers and caches. */
        if(!yaffs_InitialiseTempBuffers(dev))
                init_failed = 1;
-       
+
        dev->srCache = NULL;
        dev->gcCleanupList = NULL;
-       
-       
+
+
        if (!init_failed &&
            dev->nShortOpCaches > 0) {
                int i;
@@ -7211,10 +7211,10 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
                }
 
                buf = dev->srCache =  YMALLOC(srCacheBytes);
-                   
+
                if(dev->srCache)
                        memset(dev->srCache,0,srCacheBytes);
-                  
+
                for (i = 0; i < dev->nShortOpCaches && buf; i++) {
                        dev->srCache[i].object = NULL;
                        dev->srCache[i].lastUse = 0;
@@ -7223,12 +7223,12 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
                }
                if(!buf)
                        init_failed = 1;
-                       
+
                dev->srLastUse = 0;
        }
 
        dev->cacheHits = 0;
-       
+
        if(!init_failed){
                dev->gcCleanupList = YMALLOC(dev->nChunksPerBlock * sizeof(__u32));
                if(!dev->gcCleanupList)
@@ -7240,7 +7240,7 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
        }
        if(!init_failed && !yaffs_InitialiseBlocks(dev))
                init_failed = 1;
-               
+
        yaffs_InitialiseTnodes(dev);
        yaffs_InitialiseObjects(dev);
 
@@ -7256,14 +7256,14 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
                                  (TSTR("yaffs: restored from checkpoint" TENDSTR)));
                        } else {
 
-                               /* Clean up the mess caused by an aborted checkpoint load 
-                                * and scan backwards. 
+                               /* Clean up the mess caused by an aborted checkpoint load
+                                * and scan backwards.
                                 */
                                yaffs_DeinitialiseBlocks(dev);
                                yaffs_DeinitialiseTnodes(dev);
                                yaffs_DeinitialiseObjects(dev);
-                               
-                       
+
+
                                dev->nErasedBlocks = 0;
                                dev->nFreeChunks = 0;
                                dev->allocationBlock = -1;
@@ -7275,7 +7275,7 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
 
                                if(!init_failed && !yaffs_InitialiseBlocks(dev))
                                        init_failed = 1;
-                                       
+
                                yaffs_InitialiseTnodes(dev);
                                yaffs_InitialiseObjects(dev);
 
@@ -7289,7 +7289,7 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
                        if(!yaffs_Scan(dev))
                                init_failed = 1;
        }
-               
+
        if(init_failed){
                /* Clean up the mess */
                T(YAFFS_TRACE_TRACING,
@@ -7310,7 +7310,7 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
 
        yaffs_VerifyFreeChunks(dev);
        yaffs_VerifyBlocks(dev);
-       
+
 
        T(YAFFS_TRACE_TRACING,
          (TSTR("yaffs: yaffs_GutsInitialise() done.\n" TENDSTR)));
@@ -7394,7 +7394,7 @@ int yaffs_GetNumberOfFreeChunks(yaffs_Device * dev)
 #endif
 
        nFree += dev->nDeletedFiles;
-       
+
        /* Now count the number of dirty chunks in the cache and subtract those */
 
        {
@@ -7408,12 +7408,12 @@ int yaffs_GetNumberOfFreeChunks(yaffs_Device * dev)
        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)
@@ -7429,10 +7429,10 @@ static void yaffs_VerifyFreeChunks(yaffs_Device * dev)
 {
        int counted;
        int difference;
-       
+
        if(yaffs_SkipVerification(dev))
                return;
-       
+
        counted = yaffs_CountFreeChunks(dev);
 
        difference = dev->nFreeChunks - counted;
index 59c6e75acf4c3a36f81d59179b7022be9825d178..ea06c1a38e5f0aab1d4daaf4fa54d439e8b335f9 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
 #define YAFFS_OK       1
 #define YAFFS_FAIL  0
 
-/* Give us a  Y=0x59, 
- * Give us an A=0x41, 
- * Give us an FF=0xFF 
+/* Give us a  Y=0x59,
+ * Give us an A=0x41,
+ * Give us an FF=0xFF
  * Give us an S=0x53
- * And what have we got... 
+ * And what have we got...
  */
 #define YAFFS_MAGIC                    0x5941FF53
 
  * The range is limited slightly to help distinguish bad numbers from good.
  * This also allows us to perhaps in the future use special numbers for
  * special purposes.
- * EFFFFF00 allows the allocation of 8 blocks per second (~1Mbytes) for 15 years, 
+ * EFFFFF00 allows the allocation of 8 blocks per second (~1Mbytes) for 15 years,
  * and is a larger number than the lifetime of a 2GB device.
  */
 #define YAFFS_LOWEST_SEQUENCE_NUMBER   0x00001000
@@ -178,7 +178,7 @@ typedef struct {
 
        /* The following stuff only has meaning when we read */
        yaffs_ECCResult eccResult;
-       unsigned blockBad;      
+       unsigned blockBad;
 
        /* YAFFS 1 stuff */
        unsigned chunkDeleted;  /* The chunk is marked deleted */
@@ -244,29 +244,29 @@ typedef enum {
        /* This block is empty */
 
        YAFFS_BLOCK_STATE_ALLOCATING,
-       /* This block is partially allocated. 
+       /* This block is partially allocated.
         * At least one page holds valid data.
         * This is the one currently being used for page
         * allocation. Should never be more than one of these
         */
 
-       YAFFS_BLOCK_STATE_FULL, 
+       YAFFS_BLOCK_STATE_FULL,
        /* All the pages in this block have been allocated.
         */
 
        YAFFS_BLOCK_STATE_DIRTY,
-       /* All pages have been allocated and deleted. 
+       /* All pages have been allocated and deleted.
         * Erase me, reuse me.
         */
 
-       YAFFS_BLOCK_STATE_CHECKPOINT,   
+       YAFFS_BLOCK_STATE_CHECKPOINT,
        /* This block is assigned to holding checkpoint data.
         */
 
-       YAFFS_BLOCK_STATE_COLLECTING,   
+       YAFFS_BLOCK_STATE_COLLECTING,
        /* This block is being garbage collected */
 
-       YAFFS_BLOCK_STATE_DEAD  
+       YAFFS_BLOCK_STATE_DEAD
        /* This block has failed and is not in use */
 } yaffs_BlockState;
 
@@ -281,7 +281,7 @@ typedef struct {
        __u32 needsRetiring:1;  /* Data has failed on this block, need to get valid data off */
                                /* and retire the block. */
        __u32 skipErasedCheck: 1; /* If this is set we can skip the erased check on this block */
-       __u32 gcPrioritise: 1;  /* An ECC check or blank check has failed on this block. 
+       __u32 gcPrioritise: 1;  /* An ECC check or blank check has failed on this block.
                                   It should be prioritised for GC */
         __u32 chunkErrorStrikes:3; /* How many times we've had ecc etc failures on this block and tried to reuse it */
 
@@ -408,7 +408,7 @@ struct yaffs_ObjectStruct {
        __u8 renameAllowed:1;   /* Some objects are not allowed to be renamed. */
        __u8 unlinkAllowed:1;
        __u8 dirty:1;           /* the object needs to be written to flash */
-       __u8 valid:1;           /* When the file system is being loaded up, this 
+       __u8 valid:1;           /* When the file system is being loaded up, this
                                 * object might be created before the data
                                 * is available (ie. file data records appear before the header).
                                 */
@@ -430,11 +430,11 @@ struct yaffs_ObjectStruct {
 
        /* directory structure stuff */
        /* also used for linking up the free list */
-       struct yaffs_ObjectStruct *parent; 
+       struct yaffs_ObjectStruct *parent;
        struct list_head siblings;
 
        /* Where's my object header in NAND? */
-       int chunkId;            
+       int chunkId;
 
        int nDataChunks;        /* Number of data chunks attached to the file. */
 
@@ -490,26 +490,26 @@ typedef struct {
 } yaffs_ObjectBucket;
 
 
-/* yaffs_CheckpointObject holds the definition of an object as dumped 
+/* yaffs_CheckpointObject holds the definition of an object as dumped
  * by checkpointing.
  */
 
 typedef struct {
         int structType;
-       __u32 objectId;         
+       __u32 objectId;
        __u32 parentId;
        int chunkId;
-                       
+
        yaffs_ObjectType variantType:3;
-       __u8 deleted:1;         
-       __u8 softDeleted:1;     
-       __u8 unlinked:1;        
-       __u8 fake:1;            
+       __u8 deleted:1;
+       __u8 softDeleted:1;
+       __u8 unlinked:1;
+       __u8 fake:1;
        __u8 renameAllowed:1;
        __u8 unlinkAllowed:1;
-       __u8 serial;            
-       
-       int nDataChunks;        
+       __u8 serial;
+
+       int nDataChunks;
        __u32 fileSizeOrEquivalentObjectId;
 
 }yaffs_CheckpointObject;
@@ -539,14 +539,14 @@ struct yaffs_DeviceStruct {
        int endBlock;           /* End block we're allowed to use */
        int nReservedBlocks;    /* We want this tuneable so that we can reduce */
                                /* reserved blocks on NOR and RAM. */
-       
-       
+
+
        /* Stuff used by the shared space checkpointing mechanism */
        /* If this value is zero, then this mechanism is disabled */
-       
+
        int nCheckpointReservedBlocks; /* Blocks to reserve for checkpoint data */
 
-       
+
 
 
        int nShortOpCaches;     /* If <= 0, then short op caching is disabled, else
@@ -561,7 +561,7 @@ struct yaffs_DeviceStruct {
                                 * On an mtd this holds the mtd pointer.
                                 */
         void *superBlock;
-        
+
        /* NAND access functions (Must be set before calling YAFFS)*/
 
        int (*writeChunkToNAND) (struct yaffs_DeviceStruct * dev,
@@ -587,21 +587,21 @@ struct yaffs_DeviceStruct {
 #endif
 
        int isYaffs2;
-       
-       /* The removeObjectCallback function must be supplied by OS flavours that 
+
+       /* The removeObjectCallback function must be supplied by OS flavours that
         * need it. The Linux kernel does not use this, but yaffs direct does use
         * it to implement the faster readdir
         */
        void (*removeObjectCallback)(struct yaffs_ObjectStruct *obj);
-       
+
        /* Callback to mark the superblock dirsty */
        void (*markSuperBlockDirty)(void * superblock);
-       
+
        int wideTnodesDisabled; /* Set to disable wide tnodes */
-       
+
 
        /* End of stuff that must be set before initialisation. */
-       
+
        /* Checkpoint control. Can be set before or after initialisation */
        __u8 skipCheckpointRead;
        __u8 skipCheckpointWrite;
@@ -610,34 +610,34 @@ struct yaffs_DeviceStruct {
 
        __u16 chunkGroupBits;   /* 0 for devices <= 32MB. else log2(nchunks) - 16 */
        __u16 chunkGroupSize;   /* == 2^^chunkGroupBits */
-       
+
        /* Stuff to support wide tnodes */
        __u32 tnodeWidth;
        __u32 tnodeMask;
-       
+
        /* Stuff to support various file offses to chunk/offset translations */
        /* "Crumbs" for nDataBytesPerChunk not being a power of 2 */
        __u32 crumbMask;
        __u32 crumbShift;
        __u32 crumbsPerChunk;
-       
+
        /* Straight shifting for nDataBytesPerChunk being a power of 2 */
        __u32 chunkShift;
        __u32 chunkMask;
-       
+
 
 #ifdef __KERNEL__
 
        struct semaphore sem;   /* Semaphore for waiting on erasure.*/
        struct semaphore grossLock;     /* Gross locking semaphore */
-       __u8 *spareBuffer;      /* For mtdif2 use. Don't know the size of the buffer 
+       __u8 *spareBuffer;      /* For mtdif2 use. Don't know the size of the buffer
                                 * at compile time so we have to allocate it.
                                 */
        void (*putSuperFunc) (struct super_block * sb);
 #endif
 
        int isMounted;
-       
+
        int isCheckpointed;
 
 
@@ -646,7 +646,7 @@ struct yaffs_DeviceStruct {
        int internalEndBlock;
        int blockOffset;
        int chunkOffset;
-       
+
 
        /* Runtime checkpointing stuff */
        int checkpointPageSequence;   /* running sequence number of checkpoint pages */
@@ -662,13 +662,13 @@ struct yaffs_DeviceStruct {
        int checkpointMaxBlocks;
        __u32 checkpointSum;
        __u32 checkpointXor;
-       
+
        /* Block Info */
        yaffs_BlockInfo *blockInfo;
        __u8 *chunkBits;        /* bitmap of chunks in use */
        unsigned blockInfoAlt:1;        /* was allocated using alternative strategy */
        unsigned chunkBitsAlt:1;        /* was allocated using alternative strategy */
-       int chunkBitmapStride;  /* Number of bytes of chunkBits per block. 
+       int chunkBitmapStride;  /* Number of bytes of chunkBits per block.
                                 * Must be consistent with nChunksPerBlock.
                                 */
 
@@ -716,7 +716,7 @@ struct yaffs_DeviceStruct {
        int tagsEccUnfixed;
        int nDeletions;
        int nUnmarkedDeletions;
-       
+
        int hasPendingPrioritisedGCs; /* We think this device might have pending prioritised gcs */
 
        /* Special directories */
@@ -727,7 +727,7 @@ struct yaffs_DeviceStruct {
         *      __u8            bufferedData[YAFFS_CHUNKS_PER_BLOCK][YAFFS_BYTES_PER_CHUNK];
         *      yaffs_Spare bufferedSpare[YAFFS_CHUNKS_PER_BLOCK];
         */
-       
+
        int bufferedBlock;      /* Which block is buffered here? */
        int doingBufferedBlockRewrite;
 
@@ -768,7 +768,7 @@ typedef struct {
        int endBlock;
        int rfu[100];
 } yaffs_SuperBlockHeader;
-       
+
 /* The CheckpointDevice structure holds the device information that changes at runtime and
  * must be preserved over unmount/mount cycles.
  */
index 6e2a9de22267318f34bb7c42deabdea3a3e8dca8..466e5a44c6d548ef64f3a144941e112caab1e803 100644 (file)
@@ -172,7 +172,7 @@ int nandmtd_ReadChunkFromNAND(yaffs_Device * dev, int chunkInNAND, __u8 * data,
        __u8 *spareAsBytes = (__u8 *) spare;
 
        if (data && spare) {
-               if (dev->useNANDECC) {  
+               if (dev->useNANDECC) {
                        /* Careful, this call adds 2 ints */
                        /* to the end of the spare data.  Calling function */
                        /* should allocate enough memory for spare, */
index f75e08c23a40ef11f825f0e1e6701c579a2d111c..317600cac972c8f1b3af48652a9cff64e6a563d9 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
index ebf6647e838d7186130ea8f2ae9733b219a3bf17..6ea675611d0dcd3525bac6047031d3e2788bd990 100644 (file)
@@ -30,9 +30,9 @@ Message-Id: <200705181006.49860.ian@brightstareng.com>
 X-Virus-Scanned: by amavisd-new at brightstareng.com
 Status: R
 X-Status: NT
-X-KMail-EncryptionState:  
-X-KMail-SignatureState:  
-X-KMail-MDN-Sent:  
+X-KMail-EncryptionState:
+X-KMail-SignatureState:
+X-KMail-MDN-Sent:
 
 --Boundary-00=_5LbTGmt62YoutxM
 Content-Type: text/plain;
@@ -49,9 +49,9 @@ On Friday 18 May 2007 08:34, you wrote:
 
 Good news!
 
-Attached is a newer yaffs_mtdif1.c with a bandaid to help the 
+Attached is a newer yaffs_mtdif1.c with a bandaid to help the
 2.6.18 and 2.6.19 versions of MTD not trip on the oob read.
-See the LINUX_VERSION_CODE conditional in 
+See the LINUX_VERSION_CODE conditional in
 nandmtd1_ReadChunkWithTagsFromNAND.
 
 -imcd
@@ -361,7 +361,7 @@ int nandmtd1_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo)
 }
 
 /* Check any MTD prerequists.
- * 
+ *
  * Returns YAFFS_OK or YAFFS_FAIL.
  */
 static int nandmtd1_TestPrerequists(struct mtd_info * mtd)
index 15b5a970462ca96a73e8d2cee57ac4c9d43a9122..36d5adec5c9b94f76abd770fb40dc990b5e4d4df 100644 (file)
@@ -295,7 +295,7 @@ int nandmtd1_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo)
 }
 
 /* Check any MTD prerequists.
- * 
+ *
  * Returns YAFFS_OK or YAFFS_FAIL.
  */
 static int nandmtd1_TestPrerequists(struct mtd_info * mtd)
index d927c76737ebc796c0bdaf2f50efa5515010bc54..cdad0734bf958d6cd97dabe66f5a9f9788a985a9 100644 (file)
@@ -158,7 +158,7 @@ int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND,
 
        if (tags)
                yaffs_UnpackTags2(tags, &pt);
-       
+
        if(tags && retval == -EBADMSG && tags->eccResult == YAFFS_ECC_RESULT_NO_ERROR)
                tags->eccResult = YAFFS_ECC_RESULT_UNFIXED;
 
index e70d751c21eb9d188a0785df60a8db7bbcf33c1b..b67ba52aa42771448a3b3120dc7d947e034338be 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
index c33483c3599b8caadd5dd459514ac355ef96bb82..4e250338d741a2ca67af9bc268f9c1ac5949d10d 100644 (file)
@@ -10,7 +10,7 @@
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  */
+
 const char *yaffs_nand_c_version =
     "$Id: yaffs_nand.c,v 1.7 2007-02-14 01:09:06 wookey Exp $";
 
@@ -25,9 +25,9 @@ int yaffs_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND,
 {
        int result;
        yaffs_ExtendedTags localTags;
-       
+
        int realignedChunkInNAND = chunkInNAND - dev->chunkOffset;
-       
+
        /* If there are no tags provided, use local tags to get prioritised gc working */
        if(!tags)
                tags = &localTags;
@@ -39,14 +39,14 @@ int yaffs_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND,
                result = yaffs_TagsCompatabilityReadChunkWithTagsFromNAND(dev,
                                                                        realignedChunkInNAND,
                                                                        buffer,
-                                                                       tags);  
-       if(tags && 
+                                                                       tags);
+       if(tags &&
           tags->eccResult > YAFFS_ECC_RESULT_NO_ERROR){
-       
+
                yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, chunkInNAND/dev->nChunksPerBlock);
                 yaffs_HandleChunkError(dev,bi);
        }
-                                                               
+
        return result;
 }
 
@@ -57,7 +57,7 @@ int yaffs_WriteChunkWithTagsToNAND(yaffs_Device * dev,
 {
        chunkInNAND -= dev->chunkOffset;
 
-       
+
        if (tags) {
                tags->sequenceNumber = dev->sequenceNumber;
                tags->chunkUsed = 1;
@@ -131,4 +131,4 @@ int yaffs_InitialiseNAND(struct yaffs_DeviceStruct *dev)
 }
 
 
+
index 8ed1a2d5c4a39bc2bc20176741cd0e572562c06b..5fa334bdc924a8a9b2aa61807f1d39e368a7ea32 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
index 13520e10593210f4c70de42289268a88f5d4f2b9..cd2e96f7ae44468a040c78f68cb50b3b14a23096 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
index 627b2f8f5282da825cbb5a4d68302e408b0f8b41..776c5c256c24044300c518cf3e84bd535a74bc59 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
index 6860876c4389803fcbc4274d5caded7fd631cf51..e420f95da1918ae0738568ec263a731c9e8f9eee 100644 (file)
@@ -128,10 +128,10 @@ void yaffs_UnpackTags2(yaffs_ExtendedTags * t, yaffs_PackedTags2 * pt)
                                                  (yaffs_PackedTags2TagsPart),
                                                  &pt->ecc, &ecc);
                        switch(result){
-                               case 0: 
-                                       t->eccResult = YAFFS_ECC_RESULT_NO_ERROR; 
+                               case 0:
+                                       t->eccResult = YAFFS_ECC_RESULT_NO_ERROR;
                                        break;
-                               case 1: 
+                               case 1:
                                        t->eccResult = YAFFS_ECC_RESULT_FIXED;
                                        break;
                                case -1:
index 7c4a72c483daa83477db3df3a7d4247e1bfb6777..c2242ffe76220470bd94c7135d7ac29db7a363f6 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
index 0429838de8e5b4cfc1dd5b78ed1056db83b8ca8c..474be9cea39967774053d3e9756d888da07e304d 100644 (file)
@@ -50,7 +50,7 @@
 static __inline void
 swapfunc(char *a, char *b, int n, int swaptype)
 {
-       if (swaptype <= 1) 
+       if (swaptype <= 1)
                swapcode(long, a, b, n)
        else
                swapcode(char, a, b, n)
@@ -137,7 +137,7 @@ loop:       SWAPINIT(a, es);
        }
        if (swap_cnt == 0) {  /* Switch to insertion sort */
                for (pm = (char *) a + es; pm < (char *) a + n * es; pm += es)
-                       for (pl = pm; pl > (char *) a && cmp(pl - es, pl) > 0; 
+                       for (pl = pm; pl > (char *) a && cmp(pl - es, pl) > 0;
                             pl -= es)
                                swap(pl, pl - es);
                return;
@@ -150,7 +150,7 @@ loop:       SWAPINIT(a, es);
        vecswap(pb, pn - r, r);
        if ((r = pb - pa) > es)
                yaffs_qsort(a, r / es, es, cmp);
-       if ((r = pd - pc) > es) { 
+       if ((r = pd - pc) > es) {
                /* Iterate rather than recurse to save stack space */
                a = pn - r;
                n = r / es;
index 3ec73979de0488538264ed1de57148cddf843de0..610b7ec8493ad4fafe1f3ade5d3dd4e31a39a9f6 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
index c1edb6a19ab859e69c0456c6752959646ce03c12..a61e3ba14f1ffeff4937c61847112ca18ebf6356 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
index ba56727fffa837efb27039ca29deaf67602e4983..2fd0c24ed26c456cc88530d714680e68dc380311 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
index 0cfdfcf6baad48214d2c8ec21028ee7b6c1602c5..810837a32d9bb3285a62abbd674ad1e36f65f4e1 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
index 8b80c6d6889a6390eb41debb33345cce33b4b0b6..15ac28121c768bc8d9faa3d2f305bcf5e9e7bcf4 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
@@ -150,7 +150,7 @@ extern unsigned int yaffs_wr_attempts;
  * Tracing flags.
  * The flags masked in YAFFS_TRACE_ALWAYS are always traced.
  */
+
 #define YAFFS_TRACE_OS                 0x00000002
 #define YAFFS_TRACE_ALLOCATE           0x00000004
 #define YAFFS_TRACE_SCAN               0x00000008