projects / openwrt.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
adds missing patch for native toolchain
[openwrt.git] / target / linux / generic-2.6 / files-2.6.25 / fs / yaffs2 / yaffs_guts.c
diff --git a/target/linux/generic-2.6/files-2.6.25/fs/yaffs2/yaffs_guts.c b/target/linux/generic-2.6/files-2.6.25/fs/yaffs2/yaffs_guts.c
index 2ab8146..223f2c1 100644 (file)
--- a/target/linux/generic-2.6/files-2.6.25/fs/yaffs2/yaffs_guts.c
+++ b/target/linux/generic-2.6/files-2.6.25/fs/yaffs2/yaffs_guts.c
@@ -12,13 +12,14 @@
  */
 
 const char *yaffs_guts_c_version =
  */
 
 const char *yaffs_guts_c_version =
-    "$Id: yaffs_guts.c,v 1.49 2007-05-15 20:07:40 charles Exp $";
+    "$Id: yaffs_guts.c,v 1.56 2008-05-08 23:23:26 charles Exp $";
 
 #include "yportenv.h"
 
 #include "yaffsinterface.h"
 #include "yaffs_guts.h"
 #include "yaffs_tagsvalidity.h"
 
 #include "yportenv.h"
 
 #include "yaffsinterface.h"
 #include "yaffs_guts.h"
 #include "yaffs_tagsvalidity.h"
+#include "yaffs_getblockinfo.h"
 
 #include "yaffs_tagscompat.h"
 #ifndef  CONFIG_YAFFS_USE_OWN_SORT
 
 #include "yaffs_tagscompat.h"
 #ifndef  CONFIG_YAFFS_USE_OWN_SORT
@@ -78,9 +79,6 @@ static int yaffs_DoGenericObjectDeletion(yaffs_Object * in);
 
 static yaffs_BlockInfo *yaffs_GetBlockInfo(yaffs_Device * dev, int blockNo);
 
 
 static yaffs_BlockInfo *yaffs_GetBlockInfo(yaffs_Device * dev, int blockNo);
 
-static __u8 *yaffs_GetTempBuffer(yaffs_Device * dev, int lineNo);
-static void yaffs_ReleaseTempBuffer(yaffs_Device * dev, __u8 * buffer,
-                                   int lineNo);
 
 static int yaffs_CheckChunkErased(struct yaffs_DeviceStruct *dev,
                                  int chunkInNAND);
 
 static int yaffs_CheckChunkErased(struct yaffs_DeviceStruct *dev,
                                  int chunkInNAND);
@@ -121,23 +119,32 @@ static yaffs_Tnode *yaffs_FindLevel0Tnode(yaffs_Device * dev,
 
 /* Function to calculate chunk and offset */
 
 
 /* Function to calculate chunk and offset */
 
-static void yaffs_AddrToChunk(yaffs_Device *dev, loff_t addr, __u32 *chunk, __u32 *offset)
+static void yaffs_AddrToChunk(yaffs_Device *dev, loff_t addr, int *chunkOut, __u32 *offsetOut)
 {
 {
-       if(dev->chunkShift){
-               /* Easy-peasy power of 2 case */
-               *chunk  = (__u32)(addr >> dev->chunkShift);
-               *offset = (__u32)(addr & dev->chunkMask);
-       }
-       else if(dev->crumbsPerChunk)
+       int chunk;
+       __u32 offset;
+       
+       chunk  = (__u32)(addr >> dev->chunkShift);
+               
+       if(dev->chunkDiv == 1)
        {
        {
-               /* Case where we're using "crumbs" */
-               *offset = (__u32)(addr & dev->crumbMask);
-               addr >>= dev->crumbShift;
-               *chunk = ((__u32)addr)/dev->crumbsPerChunk;
-               *offset += ((addr - (*chunk * dev->crumbsPerChunk)) << dev->crumbShift);
+               /* easy power of 2 case */
+               offset = (__u32)(addr & dev->chunkMask);
        }
        else
        }
        else
-               YBUG();
+       {
+               /* Non power-of-2 case */
+               
+               loff_t chunkBase;
+               
+               chunk /= dev->chunkDiv;
+               
+               chunkBase = ((loff_t)chunk) * dev->nDataBytesPerChunk;
+               offset = (__u32)(addr - chunkBase);
+       }
+
+       *chunkOut = chunk;
+       *offsetOut = offset;
 }
 
 /* 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
@@ -168,7 +175,7 @@ static __u32 ShiftsGE(__u32 x)
 /* Function to return the number of shifts to get a 1 in bit 0
  */
 
 /* Function to return the number of shifts to get a 1 in bit 0
  */
 
-static __u32 ShiftDiv(__u32 x)
+static __u32 Shifts(__u32 x)
 {
        int nShifts;
 
 {
        int nShifts;
 
@@ -200,16 +207,21 @@ static int yaffs_InitialiseTempBuffers(yaffs_Device *dev)
        for (i = 0; buf && i < YAFFS_N_TEMP_BUFFERS; i++) {
                dev->tempBuffer[i].line = 0;    /* not in use */
                dev->tempBuffer[i].buffer = buf =
        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);
+                   YMALLOC_DMA(dev->totalBytesPerChunk);
        }
 
        return buf ? YAFFS_OK : YAFFS_FAIL;
 
 }
 
        }
 
        return buf ? YAFFS_OK : YAFFS_FAIL;
 
 }
 
-static __u8 *yaffs_GetTempBuffer(yaffs_Device * dev, int lineNo)
+__u8 *yaffs_GetTempBuffer(yaffs_Device * dev, int lineNo)
 {
        int i, j;
 {
        int i, j;
+
+       dev->tempInUse++;
+       if(dev->tempInUse > dev->maxTemp)
+               dev->maxTemp = dev->tempInUse;
+
        for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) {
                if (dev->tempBuffer[i].line == 0) {
                        dev->tempBuffer[i].line = lineNo;
        for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) {
                if (dev->tempBuffer[i].line == 0) {
                        dev->tempBuffer[i].line = lineNo;
@@ -242,10 +254,13 @@ static __u8 *yaffs_GetTempBuffer(yaffs_Device * dev, int lineNo)
 
 }
 
 
 }
 
-static void yaffs_ReleaseTempBuffer(yaffs_Device * dev, __u8 * buffer,
+void yaffs_ReleaseTempBuffer(yaffs_Device * dev, __u8 * buffer,
                                    int lineNo)
 {
        int i;
                                    int lineNo)
 {
        int i;
+       
+       dev->tempInUse--;
+       
        for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) {
                if (dev->tempBuffer[i].buffer == buffer) {
                        dev->tempBuffer[i].line = 0;
        for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) {
                if (dev->tempBuffer[i].buffer == buffer) {
                        dev->tempBuffer[i].line = 0;
@@ -390,11 +405,14 @@ static int yaffs_SkipVerification(yaffs_Device *dev)
        return !(yaffs_traceMask & (YAFFS_TRACE_VERIFY | YAFFS_TRACE_VERIFY_FULL));
 }
 
        return !(yaffs_traceMask & (YAFFS_TRACE_VERIFY | YAFFS_TRACE_VERIFY_FULL));
 }
 
+#if 0
 static int yaffs_SkipFullVerification(yaffs_Device *dev)
 {
        return !(yaffs_traceMask & (YAFFS_TRACE_VERIFY_FULL));
 }
 
 static int yaffs_SkipFullVerification(yaffs_Device *dev)
 {
        return !(yaffs_traceMask & (YAFFS_TRACE_VERIFY_FULL));
 }
 
+#endif
+
 static int yaffs_SkipNANDVerification(yaffs_Device *dev)
 {
        return !(yaffs_traceMask & (YAFFS_TRACE_VERIFY_NAND));
 static int yaffs_SkipNANDVerification(yaffs_Device *dev)
 {
        return !(yaffs_traceMask & (YAFFS_TRACE_VERIFY_NAND));
@@ -597,7 +615,6 @@ static int yaffs_VerifyTnodeWorker(yaffs_Object * obj, yaffs_Tnode * tn,
        int i;
        yaffs_Device *dev = obj->myDev;
        int ok = 1;
        int i;
        yaffs_Device *dev = obj->myDev;
        int ok = 1;
-       int nTnodeBytes = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
 
        if (tn) {
                if (level > 0) {
 
        if (tn) {
                if (level > 0) {
@@ -646,7 +663,6 @@ static void yaffs_VerifyFile(yaffs_Object *obj)
        __u32 lastChunk;
        __u32 x;
        __u32 i;
        __u32 lastChunk;
        __u32 x;
        __u32 i;
-       int ok;
        yaffs_Device *dev;
        yaffs_ExtendedTags tags;
        yaffs_Tnode *tn;
        yaffs_Device *dev;
        yaffs_ExtendedTags tags;
        yaffs_Tnode *tn;
@@ -829,7 +845,7 @@ static void yaffs_VerifyObjects(yaffs_Device *dev)
 {
        yaffs_Object *obj;
        int i;
 {
        yaffs_Object *obj;
        int i;
-       struct list_head *lh;
+       struct ylist_head *lh;
 
        if(yaffs_SkipVerification(dev))
                return;
 
        if(yaffs_SkipVerification(dev))
                return;
@@ -837,9 +853,9 @@ static void yaffs_VerifyObjects(yaffs_Device *dev)
        /* Iterate through the objects in each hash entry */
 
         for(i = 0; i <  YAFFS_NOBJECT_BUCKETS; i++){
        /* Iterate through the objects in each hash entry */
 
         for(i = 0; i <  YAFFS_NOBJECT_BUCKETS; i++){
-               list_for_each(lh, &dev->objectBucket[i].list) {
+               ylist_for_each(lh, &dev->objectBucket[i].list) {
                        if (lh) {
                        if (lh) {
-                               obj = list_entry(lh, yaffs_Object, hashLink);
+                               obj = ylist_entry(lh, yaffs_Object, hashLink);
                                yaffs_VerifyObject(obj);
                        }
                }
                                yaffs_VerifyObject(obj);
                        }
                }
@@ -915,7 +931,6 @@ static int yaffs_CheckChunkErased(struct yaffs_DeviceStruct *dev,
 
 }
 
 
 }
 
-
 static int yaffs_WriteNewChunkWithTagsToNAND(struct yaffs_DeviceStruct *dev,
                                             const __u8 * data,
                                             yaffs_ExtendedTags * tags,
 static int yaffs_WriteNewChunkWithTagsToNAND(struct yaffs_DeviceStruct *dev,
                                             const __u8 * data,
                                             yaffs_ExtendedTags * tags,
@@ -992,7 +1007,11 @@ static int yaffs_WriteNewChunkWithTagsToNAND(struct yaffs_DeviceStruct *dev,
                /* Copy the data into the robustification buffer */
                yaffs_HandleWriteChunkOk(dev, chunk, data, tags);
 
                /* Copy the data into the robustification buffer */
                yaffs_HandleWriteChunkOk(dev, chunk, data, tags);
 
-       } while (writeOk != YAFFS_OK && attempts < yaffs_wr_attempts);
+       } while (writeOk != YAFFS_OK &&
+               (yaffs_wr_attempts <= 0 || attempts <= yaffs_wr_attempts));
+
+       if(!writeOk)
+               chunk = -1;
 
        if (attempts > 1) {
                T(YAFFS_TRACE_ERROR,
 
        if (attempts > 1) {
                T(YAFFS_TRACE_ERROR,
@@ -1143,6 +1162,10 @@ static int yaffs_CreateTnodes(yaffs_Device * dev, int nTnodes)
         * Must be a multiple of 32-bits  */
        tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
 
         * Must be a multiple of 32-bits  */
        tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
 
+       if(tnodeSize < sizeof(yaffs_Tnode))
+               tnodeSize = sizeof(yaffs_Tnode);
+
+
        /* make these things */
 
        newTnodes = YMALLOC(nTnodes * tnodeSize);
        /* make these things */
 
        newTnodes = YMALLOC(nTnodes * tnodeSize);
@@ -1233,15 +1256,21 @@ static yaffs_Tnode *yaffs_GetTnodeRaw(yaffs_Device * dev)
                dev->nFreeTnodes--;
        }
 
                dev->nFreeTnodes--;
        }
 
+       dev->nCheckpointBlocksRequired = 0; /* force recalculation*/
+
        return tn;
 }
 
 static yaffs_Tnode *yaffs_GetTnode(yaffs_Device * dev)
 {
        yaffs_Tnode *tn = yaffs_GetTnodeRaw(dev);
        return tn;
 }
 
 static yaffs_Tnode *yaffs_GetTnode(yaffs_Device * dev)
 {
        yaffs_Tnode *tn = yaffs_GetTnodeRaw(dev);
+       int tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
+
+       if(tnodeSize < sizeof(yaffs_Tnode))
+               tnodeSize = sizeof(yaffs_Tnode);
 
        if(tn)
 
        if(tn)
-               memset(tn, 0, (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8);
+               memset(tn, 0, tnodeSize);
 
        return tn;
 }
 
        return tn;
 }
@@ -1262,6 +1291,8 @@ static void yaffs_FreeTnode(yaffs_Device * dev, yaffs_Tnode * tn)
                dev->freeTnodes = tn;
                dev->nFreeTnodes++;
        }
                dev->freeTnodes = tn;
                dev->nFreeTnodes++;
        }
+       dev->nCheckpointBlocksRequired = 0; /* force recalculation*/
+
 }
 
 static void yaffs_DeinitialiseTnodes(yaffs_Device * dev)
 }
 
 static void yaffs_DeinitialiseTnodes(yaffs_Device * dev)
@@ -1854,7 +1885,7 @@ static int yaffs_CreateFreeObjects(yaffs_Device * dev, int nObjects)
        /* Hook them into the free list */
        for (i = 0; i < nObjects - 1; i++) {
                newObjects[i].siblings.next =
        /* Hook them into the free list */
        for (i = 0; i < nObjects - 1; i++) {
                newObjects[i].siblings.next =
-                   (struct list_head *)(&newObjects[i + 1]);
+                   (struct ylist_head *)(&newObjects[i + 1]);
        }
 
        newObjects[nObjects - 1].siblings.next = (void *)dev->freeObjects;
        }
 
        newObjects[nObjects - 1].siblings.next = (void *)dev->freeObjects;
@@ -1894,9 +1925,9 @@ static yaffs_Object *yaffs_AllocateEmptyObject(yaffs_Device * dev)
                tn->myDev = dev;
                tn->chunkId = -1;
                tn->variantType = YAFFS_OBJECT_TYPE_UNKNOWN;
                tn->myDev = dev;
                tn->chunkId = -1;
                tn->variantType = YAFFS_OBJECT_TYPE_UNKNOWN;
-               INIT_LIST_HEAD(&(tn->hardLinks));
-               INIT_LIST_HEAD(&(tn->hashLink));
-               INIT_LIST_HEAD(&tn->siblings);
+               YINIT_LIST_HEAD(&(tn->hardLinks));
+               YINIT_LIST_HEAD(&(tn->hashLink));
+               YINIT_LIST_HEAD(&tn->siblings);
 
                /* Add it to the lost and found directory.
                 * NB Can't put root or lostNFound in lostNFound so
 
                /* Add it to the lost and found directory.
                 * NB Can't put root or lostNFound in lostNFound so
@@ -1907,6 +1938,8 @@ static yaffs_Object *yaffs_AllocateEmptyObject(yaffs_Device * dev)
                }
        }
 
                }
        }
 
+       dev->nCheckpointBlocksRequired = 0; /* force recalculation*/
+
        return tn;
 }
 
        return tn;
 }
 
@@ -1937,8 +1970,8 @@ static void yaffs_UnhashObject(yaffs_Object * tn)
        yaffs_Device *dev = tn->myDev;
 
        /* If it is still linked into the bucket list, free from the list */
        yaffs_Device *dev = tn->myDev;
 
        /* If it is still linked into the bucket list, free from the list */
-       if (!list_empty(&tn->hashLink)) {
-               list_del_init(&tn->hashLink);
+       if (!ylist_empty(&tn->hashLink)) {
+               ylist_del_init(&tn->hashLink);
                bucket = yaffs_HashFunction(tn->objectId);
                dev->objectBucket[bucket].count--;
        }
                bucket = yaffs_HashFunction(tn->objectId);
                dev->objectBucket[bucket].count--;
        }
@@ -1964,9 +1997,12 @@ static void yaffs_FreeObject(yaffs_Object * tn)
        yaffs_UnhashObject(tn);
 
        /* Link into the free list. */
        yaffs_UnhashObject(tn);
 
        /* Link into the free list. */
-       tn->siblings.next = (struct list_head *)(dev->freeObjects);
+       tn->siblings.next = (struct ylist_head *)(dev->freeObjects);
        dev->freeObjects = tn;
        dev->nFreeObjects++;
        dev->freeObjects = tn;
        dev->nFreeObjects++;
+
+       dev->nCheckpointBlocksRequired = 0; /* force recalculation*/
+
 }
 
 #ifdef __KERNEL__
 }
 
 #ifdef __KERNEL__
@@ -2007,7 +2043,7 @@ static void yaffs_InitialiseObjects(yaffs_Device * dev)
        dev->nFreeObjects = 0;
 
        for (i = 0; i < YAFFS_NOBJECT_BUCKETS; i++) {
        dev->nFreeObjects = 0;
 
        for (i = 0; i < YAFFS_NOBJECT_BUCKETS; i++) {
-               INIT_LIST_HEAD(&dev->objectBucket[i].list);
+               YINIT_LIST_HEAD(&dev->objectBucket[i].list);
                dev->objectBucket[i].count = 0;
        }
 
                dev->objectBucket[i].count = 0;
        }
 
@@ -2058,7 +2094,7 @@ static int yaffs_CreateNewObjectNumber(yaffs_Device * dev)
         */
 
        int found = 0;
         */
 
        int found = 0;
-       struct list_head *i;
+       struct ylist_head *i;
 
        __u32 n = (__u32) bucket;
 
 
        __u32 n = (__u32) bucket;
 
@@ -2068,10 +2104,10 @@ static int yaffs_CreateNewObjectNumber(yaffs_Device * dev)
                found = 1;
                n += YAFFS_NOBJECT_BUCKETS;
                if (1 || dev->objectBucket[bucket].count > 0) {
                found = 1;
                n += YAFFS_NOBJECT_BUCKETS;
                if (1 || dev->objectBucket[bucket].count > 0) {
-                       list_for_each(i, &dev->objectBucket[bucket].list) {
+                       ylist_for_each(i, &dev->objectBucket[bucket].list) {
                                /* If there is already one in the list */
                                if (i
                                /* If there is already one in the list */
                                if (i
-                                   && list_entry(i, yaffs_Object,
+                                   && ylist_entry(i, yaffs_Object,
                                                  hashLink)->objectId == n) {
                                        found = 0;
                                }
                                                  hashLink)->objectId == n) {
                                        found = 0;
                                }
@@ -2088,7 +2124,7 @@ static void yaffs_HashObject(yaffs_Object * in)
        int bucket = yaffs_HashFunction(in->objectId);
        yaffs_Device *dev = in->myDev;
 
        int bucket = yaffs_HashFunction(in->objectId);
        yaffs_Device *dev = in->myDev;
 
-       list_add(&in->hashLink, &dev->objectBucket[bucket].list);
+       ylist_add(&in->hashLink, &dev->objectBucket[bucket].list);
        dev->objectBucket[bucket].count++;
 
 }
        dev->objectBucket[bucket].count++;
 
 }
@@ -2096,13 +2132,13 @@ static void yaffs_HashObject(yaffs_Object * in)
 yaffs_Object *yaffs_FindObjectByNumber(yaffs_Device * dev, __u32 number)
 {
        int bucket = yaffs_HashFunction(number);
 yaffs_Object *yaffs_FindObjectByNumber(yaffs_Device * dev, __u32 number)
 {
        int bucket = yaffs_HashFunction(number);
-       struct list_head *i;
+       struct ylist_head *i;
        yaffs_Object *in;
 
        yaffs_Object *in;
 
-       list_for_each(i, &dev->objectBucket[bucket].list) {
+       ylist_for_each(i, &dev->objectBucket[bucket].list) {
                /* Look if it is in the list */
                if (i) {
                /* Look if it is in the list */
                if (i) {
-                       in = list_entry(i, yaffs_Object, hashLink);
+                       in = ylist_entry(i, yaffs_Object, hashLink);
                        if (in->objectId == number) {
 #ifdef __KERNEL__
                                /* Don't tell the VFS about this one if it is defered free */
                        if (in->objectId == number) {
 #ifdef __KERNEL__
                                /* Don't tell the VFS about this one if it is defered free */
@@ -2123,7 +2159,7 @@ yaffs_Object *yaffs_CreateNewObject(yaffs_Device * dev, int number,
 {
 
        yaffs_Object *theObject;
 {
 
        yaffs_Object *theObject;
-       yaffs_Tnode *tn;
+       yaffs_Tnode *tn = NULL;
 
        if (number < 0) {
                number = yaffs_CreateNewObjectNumber(dev);
 
        if (number < 0) {
                number = yaffs_CreateNewObjectNumber(dev);
@@ -2171,7 +2207,7 @@ yaffs_Object *yaffs_CreateNewObject(yaffs_Device * dev, int number,
                        theObject->variant.fileVariant.top = tn;
                        break;
                case YAFFS_OBJECT_TYPE_DIRECTORY:
                        theObject->variant.fileVariant.top = tn;
                        break;
                case YAFFS_OBJECT_TYPE_DIRECTORY:
-                       INIT_LIST_HEAD(&theObject->variant.directoryVariant.
+                       YINIT_LIST_HEAD(&theObject->variant.directoryVariant.
                                       children);
                        break;
                case YAFFS_OBJECT_TYPE_SYMLINK:
                                       children);
                        break;
                case YAFFS_OBJECT_TYPE_SYMLINK:
@@ -2238,7 +2274,7 @@ static yaffs_Object *yaffs_MknodObject(yaffs_ObjectType type,
                                       const YCHAR * aliasString, __u32 rdev)
 {
        yaffs_Object *in;
                                       const YCHAR * aliasString, __u32 rdev)
 {
        yaffs_Object *in;
-       YCHAR *str;
+       YCHAR *str = NULL;
 
        yaffs_Device *dev = parent->myDev;
 
 
        yaffs_Device *dev = parent->myDev;
 
@@ -2296,7 +2332,7 @@ static yaffs_Object *yaffs_MknodObject(yaffs_ObjectType type,
                            equivalentObject;
                        in->variant.hardLinkVariant.equivalentObjectId =
                            equivalentObject->objectId;
                            equivalentObject;
                        in->variant.hardLinkVariant.equivalentObjectId =
                            equivalentObject->objectId;
-                       list_add(&in->hardLinks, &equivalentObject->hardLinks);
+                       ylist_add(&in->hardLinks, &equivalentObject->hardLinks);
                        break;
                case YAFFS_OBJECT_TYPE_FILE:
                case YAFFS_OBJECT_TYPE_DIRECTORY:
                        break;
                case YAFFS_OBJECT_TYPE_FILE:
                case YAFFS_OBJECT_TYPE_DIRECTORY:
@@ -2457,7 +2493,7 @@ int yaffs_RenameObject(yaffs_Object * oldDir, const YCHAR * oldName,
                existingTarget = yaffs_FindObjectByName(newDir, newName);
                if (existingTarget &&
                    existingTarget->variantType == YAFFS_OBJECT_TYPE_DIRECTORY &&
                existingTarget = yaffs_FindObjectByName(newDir, newName);
                if (existingTarget &&
                    existingTarget->variantType == YAFFS_OBJECT_TYPE_DIRECTORY &&
-                   !list_empty(&existingTarget->variant.directoryVariant.children)) {
+                   !ylist_empty(&existingTarget->variant.directoryVariant.children)) {
                        /* There is a target that is a non-empty directory, so we fail */
                        return YAFFS_FAIL;      /* EEXIST or ENOTEMPTY */
                } else if (existingTarget && existingTarget != obj) {
                        /* There is a target that is a non-empty directory, so we fail */
                        return YAFFS_FAIL;      /* EEXIST or ENOTEMPTY */
                } else if (existingTarget && existingTarget != obj) {
@@ -2801,6 +2837,40 @@ static int yaffs_FindBlockForAllocation(yaffs_Device * dev)
 }
 
 
 }
 
 
+
+static int yaffs_CalcCheckpointBlocksRequired(yaffs_Device *dev)
+{
+       if(!dev->nCheckpointBlocksRequired){
+               /* Not a valid value so recalculate */
+               int nBytes = 0;
+               int nBlocks;
+               int devBlocks = (dev->endBlock - dev->startBlock + 1);
+               int tnodeSize;
+
+               tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
+
+               if(tnodeSize < sizeof(yaffs_Tnode))
+                       tnodeSize = sizeof(yaffs_Tnode);
+
+               nBytes += sizeof(yaffs_CheckpointValidity);
+               nBytes += sizeof(yaffs_CheckpointDevice);
+               nBytes += devBlocks * sizeof(yaffs_BlockInfo);
+               nBytes += devBlocks * dev->chunkBitmapStride;
+               nBytes += (sizeof(yaffs_CheckpointObject) + sizeof(__u32)) * (dev->nObjectsCreated - dev->nFreeObjects);
+               nBytes += (tnodeSize + sizeof(__u32)) * (dev->nTnodesCreated - dev->nFreeTnodes);
+               nBytes += sizeof(yaffs_CheckpointValidity);
+               nBytes += sizeof(__u32); /* checksum*/
+
+               /* Round up and add 2 blocks to allow for some bad blocks, so add 3 */
+
+               nBlocks = (nBytes/(dev->nDataBytesPerChunk * dev->nChunksPerBlock)) + 3;
+
+               dev->nCheckpointBlocksRequired = nBlocks;
+       }
+
+       return dev->nCheckpointBlocksRequired;
+}
+
 // Check if there's space to allocate...
 // Thinks.... do we need top make this ths same as yaffs_GetFreeChunks()?
 static int yaffs_CheckSpaceForAllocation(yaffs_Device * dev)
 // Check if there's space to allocate...
 // Thinks.... do we need top make this ths same as yaffs_GetFreeChunks()?
 static int yaffs_CheckSpaceForAllocation(yaffs_Device * dev)
@@ -2809,7 +2879,7 @@ static int yaffs_CheckSpaceForAllocation(yaffs_Device * dev)
        int reservedBlocks = dev->nReservedBlocks;
        int checkpointBlocks;
 
        int reservedBlocks = dev->nReservedBlocks;
        int checkpointBlocks;
 
-       checkpointBlocks =  dev->nCheckpointReservedBlocks - dev->blocksInCheckpoint;
+       checkpointBlocks =  yaffs_CalcCheckpointBlocksRequired(dev) - dev->blocksInCheckpoint;
        if(checkpointBlocks < 0)
                checkpointBlocks = 0;
 
        if(checkpointBlocks < 0)
                checkpointBlocks = 0;
 
@@ -3037,7 +3107,7 @@ static int yaffs_GarbageCollectBlock(yaffs_Device * dev, int block)
                                                yaffs_ObjectHeader *oh;
                                                oh = (yaffs_ObjectHeader *)buffer;
                                                oh->isShrink = 0;
                                                yaffs_ObjectHeader *oh;
                                                oh = (yaffs_ObjectHeader *)buffer;
                                                oh->isShrink = 0;
-                                               oh->shadowsObject = -1;
+                                               oh->shadowsObject = oh->inbandShadowsObject = -1;
                                                tags.extraShadows = 0;
                                                tags.extraIsShrinkHeader = 0;
 
                                                tags.extraShadows = 0;
                                                tags.extraIsShrinkHeader = 0;
 
@@ -3142,7 +3212,7 @@ static int yaffs_CheckGarbageCollection(yaffs_Device * dev)
        do {
                maxTries++;
 
        do {
                maxTries++;
 
-               checkpointBlockAdjust = (dev->nCheckpointReservedBlocks - dev->blocksInCheckpoint);
+               checkpointBlockAdjust = yaffs_CalcCheckpointBlocksRequired(dev) - dev->blocksInCheckpoint;
                if(checkpointBlockAdjust < 0)
                        checkpointBlockAdjust = 0;
 
                if(checkpointBlockAdjust < 0)
                        checkpointBlockAdjust = 0;
 
@@ -3628,7 +3698,7 @@ int yaffs_UpdateObjectHeader(yaffs_Object * in, const YCHAR * name, int force,
 
                oh->type = in->variantType;
                oh->yst_mode = in->yst_mode;
 
                oh->type = in->variantType;
                oh->yst_mode = in->yst_mode;
-               oh->shadowsObject = shadows;
+               oh->shadowsObject = oh->inbandShadowsObject = shadows;
 
 #ifdef CONFIG_YAFFS_WINCE
                oh->win_atime[0] = in->win_atime[0];
 
 #ifdef CONFIG_YAFFS_WINCE
                oh->win_atime[0] = in->win_atime[0];
@@ -4220,7 +4290,11 @@ static int yaffs_CheckpointTnodeWorker(yaffs_Object * in, yaffs_Tnode * tn,
        int i;
        yaffs_Device *dev = in->myDev;
        int ok = 1;
        int i;
        yaffs_Device *dev = in->myDev;
        int ok = 1;
-       int nTnodeBytes = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
+       int tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
+
+       if(tnodeSize < sizeof(yaffs_Tnode))
+               tnodeSize = sizeof(yaffs_Tnode);
+
 
        if (tn) {
                if (level > 0) {
 
        if (tn) {
                if (level > 0) {
@@ -4238,7 +4312,7 @@ static int yaffs_CheckpointTnodeWorker(yaffs_Object * in, yaffs_Tnode * tn,
                        /* printf("write tnode at %d\n",baseOffset); */
                        ok = (yaffs_CheckpointWrite(dev,&baseOffset,sizeof(baseOffset)) == sizeof(baseOffset));
                        if(ok)
                        /* printf("write tnode at %d\n",baseOffset); */
                        ok = (yaffs_CheckpointWrite(dev,&baseOffset,sizeof(baseOffset)) == sizeof(baseOffset));
                        if(ok)
-                               ok = (yaffs_CheckpointWrite(dev,tn,nTnodeBytes) == nTnodeBytes);
+                               ok = (yaffs_CheckpointWrite(dev,tn,tnodeSize) == tnodeSize);
                }
        }
 
                }
        }
 
@@ -4272,6 +4346,10 @@ static int yaffs_ReadCheckpointTnodes(yaffs_Object *obj)
        yaffs_FileStructure *fileStructPtr = &obj->variant.fileVariant;
        yaffs_Tnode *tn;
        int nread = 0;
        yaffs_FileStructure *fileStructPtr = &obj->variant.fileVariant;
        yaffs_Tnode *tn;
        int nread = 0;
+       int tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
+
+       if(tnodeSize < sizeof(yaffs_Tnode))
+               tnodeSize = sizeof(yaffs_Tnode);
 
        ok = (yaffs_CheckpointRead(dev,&baseChunk,sizeof(baseChunk)) == sizeof(baseChunk));
 
 
        ok = (yaffs_CheckpointRead(dev,&baseChunk,sizeof(baseChunk)) == sizeof(baseChunk));
 
@@ -4283,8 +4361,7 @@ static int yaffs_ReadCheckpointTnodes(yaffs_Object *obj)
                /* printf("read  tnode at %d\n",baseChunk); */
                tn = yaffs_GetTnodeRaw(dev);
                if(tn)
                /* printf("read  tnode at %d\n",baseChunk); */
                tn = yaffs_GetTnodeRaw(dev);
                if(tn)
-                       ok = (yaffs_CheckpointRead(dev,tn,(dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8) ==
-                             (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8);
+                       ok = (yaffs_CheckpointRead(dev,tn,tnodeSize) == tnodeSize);
                else
                        ok = 0;
 
                else
                        ok = 0;
 
@@ -4315,7 +4392,7 @@ static int yaffs_WriteCheckpointObjects(yaffs_Device *dev)
        yaffs_CheckpointObject cp;
        int i;
        int ok = 1;
        yaffs_CheckpointObject cp;
        int i;
        int ok = 1;
-       struct list_head *lh;
+       struct ylist_head *lh;
 
 
        /* Iterate through the objects in each hash entry,
 
 
        /* Iterate through the objects in each hash entry,
@@ -4323,9 +4400,9 @@ static int yaffs_WriteCheckpointObjects(yaffs_Device *dev)
         */
 
         for(i = 0; ok &&  i <  YAFFS_NOBJECT_BUCKETS; i++){
         */
 
         for(i = 0; ok &&  i <  YAFFS_NOBJECT_BUCKETS; i++){
-               list_for_each(lh, &dev->objectBucket[i].list) {
+               ylist_for_each(lh, &dev->objectBucket[i].list) {
                        if (lh) {
                        if (lh) {
-                               obj = list_entry(lh, yaffs_Object, hashLink);
+                               obj = ylist_entry(lh, yaffs_Object, hashLink);
                                if (!obj->deferedFree) {
                                        yaffs_ObjectToCheckpointObject(&cp,obj);
                                        cp.structType = sizeof(cp);
                                if (!obj->deferedFree) {
                                        yaffs_ObjectToCheckpointObject(&cp,obj);
                                        cp.structType = sizeof(cp);
@@ -4383,7 +4460,7 @@ static int yaffs_ReadCheckpointObjects(yaffs_Device *dev)
                                        ok = yaffs_ReadCheckpointTnodes(obj);
                                } else if(obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) {
                                        obj->hardLinks.next =
                                        ok = yaffs_ReadCheckpointTnodes(obj);
                                } else if(obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) {
                                        obj->hardLinks.next =
-                                                   (struct list_head *)
+                                                   (struct ylist_head *)
                                                    hardList;
                                        hardList = obj;
                                }
                                                    hardList;
                                        hardList = obj;
                                }
@@ -4589,7 +4666,7 @@ int yaffs_ReadDataFromFile(yaffs_Object * in, __u8 * buffer, loff_t offset,
 {
 
        int chunk;
 {
 
        int chunk;
-       int start;
+       __u32 start;
        int nToCopy;
        int n = nBytes;
        int nDone = 0;
        int nToCopy;
        int n = nBytes;
        int nDone = 0;
@@ -4617,10 +4694,10 @@ int yaffs_ReadDataFromFile(yaffs_Object * in, __u8 * buffer, loff_t offset,
                cache = yaffs_FindChunkCache(in, chunk);
 
                /* If the chunk is already in the cache or it is less than a whole chunk
                cache = yaffs_FindChunkCache(in, chunk);
 
                /* If the chunk is already in the cache or it is less than a whole chunk
-                * then use the cache (if there is caching)
+                * or we're using inband tags then use the cache (if there is caching)
                 * else bypass the cache.
                 */
                 * else bypass the cache.
                 */
-               if (cache || nToCopy != dev->nDataBytesPerChunk) {
+               if (cache || nToCopy != dev->nDataBytesPerChunk || dev->inbandTags) {
                        if (dev->nShortOpCaches > 0) {
 
                                /* If we can't find the data in the cache, then load it up. */
                        if (dev->nShortOpCaches > 0) {
 
                                /* If we can't find the data in the cache, then load it up. */
@@ -4709,7 +4786,7 @@ int yaffs_WriteDataToFile(yaffs_Object * in, const __u8 * buffer, loff_t offset,
 {
 
        int chunk;
 {
 
        int chunk;
-       int start;
+       __u32 start;
        int nToCopy;
        int n = nBytes;
        int nDone = 0;
        int nToCopy;
        int n = nBytes;
        int nDone = 0;
@@ -4757,8 +4834,10 @@ int yaffs_WriteDataToFile(yaffs_Object * in, const __u8 * buffer, loff_t offset,
                        nToWriteBack = dev->nDataBytesPerChunk;
                }
 
                        nToWriteBack = dev->nDataBytesPerChunk;
                }
 
-               if (nToCopy != dev->nDataBytesPerChunk) {
-                       /* An incomplete start or end chunk (or maybe both start and end chunk) */
+               if (nToCopy != dev->nDataBytesPerChunk || dev->inbandTags) {
+                       /* An incomplete start or end chunk (or maybe both start and end chunk), 
+                        * or we're using inband tags, so we want to use the cache buffers.
+                        */
                        if (dev->nShortOpCaches > 0) {
                                yaffs_ChunkCache *cache;
                                /* If we can't find the data in the cache, then load the cache */
                        if (dev->nShortOpCaches > 0) {
                                yaffs_ChunkCache *cache;
                                /* If we can't find the data in the cache, then load the cache */
@@ -4846,7 +4925,8 @@ int yaffs_WriteDataToFile(yaffs_Object * in, const __u8 * buffer, loff_t offset,
                        }
 
                } else {
                        }
 
                } else {
-
+                       /* A full chunk. Write directly from the supplied buffer. */
+                       
 #ifdef CONFIG_YAFFS_WINCE
                        /* Under WinCE can't do direct transfer. Need to use a local buffer.
                         * This is because we otherwise screw up WinCE's memory mapper
 #ifdef CONFIG_YAFFS_WINCE
                        /* Under WinCE can't do direct transfer. Need to use a local buffer.
                         * This is because we otherwise screw up WinCE's memory mapper
@@ -4865,7 +4945,7 @@ int yaffs_WriteDataToFile(yaffs_Object * in, const __u8 * buffer, loff_t offset,
                                                         0);
                        yaffs_ReleaseTempBuffer(dev, localBuffer, __LINE__);
 #else
                                                         0);
                        yaffs_ReleaseTempBuffer(dev, localBuffer, __LINE__);
 #else
-                       /* A full chunk. Write directly from the supplied buffer. */
+
                        chunkWritten =
                            yaffs_WriteChunkDataToObject(in, chunk, buffer,
                                                         dev->nDataBytesPerChunk,
                        chunkWritten =
                            yaffs_WriteChunkDataToObject(in, chunk, buffer,
                                                         dev->nDataBytesPerChunk,
@@ -4943,7 +5023,7 @@ int yaffs_ResizeFile(yaffs_Object * in, loff_t newSize)
 {
 
        int oldFileSize = in->variant.fileVariant.fileSize;
 {
 
        int oldFileSize = in->variant.fileVariant.fileSize;
-       int newSizeOfPartialChunk;
+       __u32 newSizeOfPartialChunk;
        int newFullChunks;
 
        yaffs_Device *dev = in->myDev;
        int newFullChunks;
 
        yaffs_Device *dev = in->myDev;
@@ -4956,11 +5036,11 @@ int yaffs_ResizeFile(yaffs_Object * in, loff_t newSize)
        yaffs_CheckGarbageCollection(dev);
 
        if (in->variantType != YAFFS_OBJECT_TYPE_FILE) {
        yaffs_CheckGarbageCollection(dev);
 
        if (in->variantType != YAFFS_OBJECT_TYPE_FILE) {
-               return yaffs_GetFileSize(in);
+               return YAFFS_FAIL;
        }
 
        if (newSize == oldFileSize) {
        }
 
        if (newSize == oldFileSize) {
-               return oldFileSize;
+               return YAFFS_OK;
        }
 
        if (newSize < oldFileSize) {
        }
 
        if (newSize < oldFileSize) {
@@ -5005,7 +5085,7 @@ int yaffs_ResizeFile(yaffs_Object * in, loff_t newSize)
                                         (newSize < oldFileSize) ? 1 : 0, 0);
        }
 
                                         (newSize < oldFileSize) ? 1 : 0, 0);
        }
 
-       return newSize;
+       return YAFFS_OK;
 }
 
 loff_t yaffs_GetFileSize(yaffs_Object * obj)
 }
 
 loff_t yaffs_GetFileSize(yaffs_Object * obj)
@@ -5058,7 +5138,7 @@ static int yaffs_DoGenericObjectDeletion(yaffs_Object * in)
 
        if (in->myDev->isYaffs2 && (in->parent != in->myDev->deletedDir)) {
                /* Move to the unlinked directory so we have a record that it was deleted. */
 
        if (in->myDev->isYaffs2 && (in->parent != in->myDev->deletedDir)) {
                /* Move to the unlinked directory so we have a record that it was deleted. */
-               yaffs_ChangeObjectName(in, in->myDev->deletedDir,"deleted", 0, 0);
+               yaffs_ChangeObjectName(in, in->myDev->deletedDir,_Y("deleted"), 0, 0);
 
        }
 
 
        }
 
@@ -5096,7 +5176,7 @@ static int yaffs_UnlinkFile(yaffs_Object * in)
                if (immediateDeletion) {
                        retVal =
                            yaffs_ChangeObjectName(in, in->myDev->deletedDir,
                if (immediateDeletion) {
                        retVal =
                            yaffs_ChangeObjectName(in, in->myDev->deletedDir,
-                                                  "deleted", 0, 0);
+                                                  _Y("deleted"), 0, 0);
                        T(YAFFS_TRACE_TRACING,
                          (TSTR("yaffs: immediate deletion of file %d" TENDSTR),
                           in->objectId));
                        T(YAFFS_TRACE_TRACING,
                          (TSTR("yaffs: immediate deletion of file %d" TENDSTR),
                           in->objectId));
@@ -5109,7 +5189,7 @@ static int yaffs_UnlinkFile(yaffs_Object * in)
                } else {
                        retVal =
                            yaffs_ChangeObjectName(in, in->myDev->unlinkedDir,
                } else {
                        retVal =
                            yaffs_ChangeObjectName(in, in->myDev->unlinkedDir,
-                                                  "unlinked", 0, 0);
+                                                  _Y("unlinked"), 0, 0);
                }
 
        }
                }
 
        }
@@ -5144,7 +5224,7 @@ int yaffs_DeleteFile(yaffs_Object * in)
 static int yaffs_DeleteDirectory(yaffs_Object * in)
 {
        /* First check that the directory is empty. */
 static int yaffs_DeleteDirectory(yaffs_Object * in)
 {
        /* First check that the directory is empty. */
-       if (list_empty(&in->variant.directoryVariant.children)) {
+       if (ylist_empty(&in->variant.directoryVariant.children)) {
                return yaffs_DoGenericObjectDeletion(in);
        }
 
                return yaffs_DoGenericObjectDeletion(in);
        }
 
@@ -5164,7 +5244,7 @@ static int yaffs_DeleteHardLink(yaffs_Object * in)
        /* remove this hardlink from the list assocaited with the equivalent
         * object
         */
        /* remove this hardlink from the list assocaited with the equivalent
         * object
         */
-       list_del(&in->hardLinks);
+       ylist_del(&in->hardLinks);
        return yaffs_DoGenericObjectDeletion(in);
 }
 
        return yaffs_DoGenericObjectDeletion(in);
 }
 
@@ -5196,7 +5276,7 @@ static int yaffs_UnlinkWorker(yaffs_Object * obj)
 
        if (obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) {
                return yaffs_DeleteHardLink(obj);
 
        if (obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) {
                return yaffs_DeleteHardLink(obj);
-       } else if (!list_empty(&obj->hardLinks)) {
+       } else if (!ylist_empty(&obj->hardLinks)) {
                /* Curve ball: We're unlinking an object that has a hardlink.
                 *
                 * This problem arises because we are not strictly following
                /* Curve ball: We're unlinking an object that has a hardlink.
                 *
                 * This problem arises because we are not strictly following
@@ -5215,10 +5295,10 @@ static int yaffs_UnlinkWorker(yaffs_Object * obj)
                int retVal;
                YCHAR name[YAFFS_MAX_NAME_LENGTH + 1];
 
                int retVal;
                YCHAR name[YAFFS_MAX_NAME_LENGTH + 1];
 
-               hl = list_entry(obj->hardLinks.next, yaffs_Object, hardLinks);
+               hl = ylist_entry(obj->hardLinks.next, yaffs_Object, hardLinks);
 
 
-               list_del_init(&hl->hardLinks);
-               list_del_init(&hl->siblings);
+               ylist_del_init(&hl->hardLinks);
+               ylist_del_init(&hl->siblings);
 
                yaffs_GetObjectName(hl, name, YAFFS_MAX_NAME_LENGTH + 1);
 
 
                yaffs_GetObjectName(hl, name, YAFFS_MAX_NAME_LENGTH + 1);
 
@@ -5325,13 +5405,13 @@ static void yaffs_HardlinkFixup(yaffs_Device *dev, yaffs_Object *hardList)
                if (in) {
                        /* Add the hardlink pointers */
                        hl->variant.hardLinkVariant.equivalentObject = in;
                if (in) {
                        /* Add the hardlink pointers */
                        hl->variant.hardLinkVariant.equivalentObject = in;
-                       list_add(&hl->hardLinks, &in->hardLinks);
+                       ylist_add(&hl->hardLinks, &in->hardLinks);
                } else {
                        /* Todo Need to report/handle this better.
                         * Got a problem... hardlink to a non-existant object
                         */
                        hl->variant.hardLinkVariant.equivalentObject = NULL;
                } else {
                        /* Todo Need to report/handle this better.
                         * Got a problem... hardlink to a non-existant object
                         */
                        hl->variant.hardLinkVariant.equivalentObject = NULL;
-                       INIT_LIST_HEAD(&hl->hardLinks);
+                       YINIT_LIST_HEAD(&hl->hardLinks);
 
                }
 
 
                }
 
@@ -5371,7 +5451,7 @@ static int yaffs_Scan(yaffs_Device * dev)
        yaffs_BlockState state;
        yaffs_Object *hardList = NULL;
        yaffs_BlockInfo *bi;
        yaffs_BlockState state;
        yaffs_Object *hardList = NULL;
        yaffs_BlockInfo *bi;
-       int sequenceNumber;
+       __u32 sequenceNumber;
        yaffs_ObjectHeader *oh;
        yaffs_Object *in;
        yaffs_Object *parent;
        yaffs_ObjectHeader *oh;
        yaffs_Object *in;
        yaffs_Object *parent;
@@ -5488,6 +5568,8 @@ static int yaffs_Scan(yaffs_Device * dev)
        for (blockIterator = startIterator; !alloc_failed && blockIterator <= endIterator;
             blockIterator++) {
 
        for (blockIterator = startIterator; !alloc_failed && blockIterator <= endIterator;
             blockIterator++) {
 
+               YYIELD();
+               
                if (dev->isYaffs2) {
                        /* get the block to scan in the correct order */
                        blk = blockIndex[blockIterator].block;
                if (dev->isYaffs2) {
                        /* get the block to scan in the correct order */
                        blk = blockIndex[blockIterator].block;
@@ -5548,8 +5630,7 @@ static int yaffs_Scan(yaffs_Device * dev)
                                                bi->sequenceNumber)) {
                                                T(YAFFS_TRACE_ALWAYS,
                                                  (TSTR
                                                bi->sequenceNumber)) {
                                                T(YAFFS_TRACE_ALWAYS,
                                                  (TSTR
-                                                  ("yaffs: Allocation block %d was not highest sequence id:"
-                                                   " block seq = %d, dev seq = %d"
+                                                  ("yaffs: Allocation block %d was not highest sequence id: block seq = %d, dev seq = %d"
                                                    TENDSTR), blk,bi->sequenceNumber,dev->sequenceNumber));
                                        }
                                }
                                                    TENDSTR), blk,bi->sequenceNumber,dev->sequenceNumber));
                                        }
                                }
@@ -5723,7 +5804,7 @@ static int yaffs_Scan(yaffs_Device * dev)
                                                /* Set up as a directory */
                                                parent->variantType =
                                                    YAFFS_OBJECT_TYPE_DIRECTORY;
                                                /* Set up as a directory */
                                                parent->variantType =
                                                    YAFFS_OBJECT_TYPE_DIRECTORY;
-                                               INIT_LIST_HEAD(&parent->variant.
+                                               YINIT_LIST_HEAD(&parent->variant.
                                                               directoryVariant.
                                                               children);
                                        } else if (parent->variantType !=
                                                               directoryVariant.
                                                               children);
                                        } else if (parent->variantType !=
@@ -5735,8 +5816,7 @@ static int yaffs_Scan(yaffs_Device * dev)
 
                                                T(YAFFS_TRACE_ERROR,
                                                  (TSTR
 
                                                T(YAFFS_TRACE_ERROR,
                                                  (TSTR
-                                                  ("yaffs tragedy: attempting to use non-directory as"
-                                                   " a directory in scan. Put in lost+found."
+                                                  ("yaffs tragedy: attempting to use non-directory as a directory in scan. Put in lost+found."
                                                    TENDSTR)));
                                                parent = dev->lostNFoundDir;
                                        }
                                                    TENDSTR)));
                                                parent = dev->lostNFoundDir;
                                        }
@@ -5781,7 +5861,7 @@ static int yaffs_Scan(yaffs_Device * dev)
                                                    equivalentObjectId =
                                                    oh->equivalentObjectId;
                                                in->hardLinks.next =
                                                    equivalentObjectId =
                                                    oh->equivalentObjectId;
                                                in->hardLinks.next =
-                                                   (struct list_head *)
+                                                   (struct ylist_head *)
                                                    hardList;
                                                hardList = in;
                                                break;
                                                    hardList;
                                                hardList = in;
                                                break;
@@ -5840,16 +5920,16 @@ static int yaffs_Scan(yaffs_Device * dev)
         * just delete them.
         */
        {
         * just delete them.
         */
        {
-               struct list_head *i;
-               struct list_head *n;
+               struct ylist_head *i;
+               struct ylist_head *n;
 
                yaffs_Object *l;
                /* Soft delete all the unlinked files */
 
                yaffs_Object *l;
                /* Soft delete all the unlinked files */
-               list_for_each_safe(i, n,
+               ylist_for_each_safe(i, n,
                                   &dev->unlinkedDir->variant.directoryVariant.
                                   children) {
                        if (i) {
                                   &dev->unlinkedDir->variant.directoryVariant.
                                   children) {
                        if (i) {
-                               l = list_entry(i, yaffs_Object, siblings);
+                               l = ylist_entry(i, yaffs_Object, siblings);
                                yaffs_DestroyObject(l);
                        }
                }
                                yaffs_DestroyObject(l);
                        }
                }
@@ -5938,7 +6018,7 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
        yaffs_BlockState state;
        yaffs_Object *hardList = NULL;
        yaffs_BlockInfo *bi;
        yaffs_BlockState state;
        yaffs_Object *hardList = NULL;
        yaffs_BlockInfo *bi;
-       int sequenceNumber;
+       __u32 sequenceNumber;
        yaffs_ObjectHeader *oh;
        yaffs_Object *in;
        yaffs_Object *parent;
        yaffs_ObjectHeader *oh;
        yaffs_Object *in;
        yaffs_Object *parent;
@@ -6053,8 +6133,10 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
 
        /* Sort the blocks */
 #ifndef CONFIG_YAFFS_USE_OWN_SORT
 
        /* Sort the blocks */
 #ifndef CONFIG_YAFFS_USE_OWN_SORT
-       yaffs_qsort(blockIndex, nBlocksToScan,
-               sizeof(yaffs_BlockIndex), ybicmp);
+       {
+               /* Use qsort now. */
+               yaffs_qsort(blockIndex, nBlocksToScan, sizeof(yaffs_BlockIndex), ybicmp);
+       }
 #else
        {
                /* Dungy old bubble sort... */
 #else
        {
                /* Dungy old bubble sort... */
@@ -6265,6 +6347,12 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
                                                                        NULL);
 
                                        oh = (yaffs_ObjectHeader *) chunkData;
                                                                        NULL);
 
                                        oh = (yaffs_ObjectHeader *) chunkData;
+                                       
+                                       if(dev->inbandTags){
+                                               /* Fix up the header if they got corrupted by inband tags */
+                                               oh->shadowsObject = oh->inbandShadowsObject;
+                                               oh->isShrink = oh->inbandIsShrink;
+                                       }
 
                                        if (!in)
                                                in = yaffs_FindOrCreateObjectByNumber(dev, tags.objectId, oh->type);
 
                                        if (!in)
                                                in = yaffs_FindOrCreateObjectByNumber(dev, tags.objectId, oh->type);
@@ -6275,8 +6363,7 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
                                        /* TODO Hoosterman we have a problem! */
                                        T(YAFFS_TRACE_ERROR,
                                          (TSTR
                                        /* TODO Hoosterman we have a problem! */
                                        T(YAFFS_TRACE_ERROR,
                                          (TSTR
-                                          ("yaffs tragedy: Could not make object for object  %d  "
-                                           "at chunk %d during scan"
+                                          ("yaffs tragedy: Could not make object for object  %d at chunk %d during scan"
                                            TENDSTR), tags.objectId, chunk));
 
                                }
                                            TENDSTR), tags.objectId, chunk));
 
                                }
@@ -6434,7 +6521,7 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
                                                /* Set up as a directory */
                                                parent->variantType =
                                                    YAFFS_OBJECT_TYPE_DIRECTORY;
                                                /* Set up as a directory */
                                                parent->variantType =
                                                    YAFFS_OBJECT_TYPE_DIRECTORY;
-                                               INIT_LIST_HEAD(&parent->variant.
+                                               YINIT_LIST_HEAD(&parent->variant.
                                                               directoryVariant.
                                                               children);
                                        } else if (parent->variantType !=
                                                               directoryVariant.
                                                               children);
                                        } else if (parent->variantType !=
@@ -6446,8 +6533,7 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
 
                                                T(YAFFS_TRACE_ERROR,
                                                  (TSTR
 
                                                T(YAFFS_TRACE_ERROR,
                                                  (TSTR
-                                                  ("yaffs tragedy: attempting to use non-directory as"
-                                                   " a directory in scan. Put in lost+found."
+                                                  ("yaffs tragedy: attempting to use non-directory as a directory in scan. Put in lost+found."
                                                    TENDSTR)));
                                                parent = dev->lostNFoundDir;
                                        }
                                                    TENDSTR)));
                                                parent = dev->lostNFoundDir;
                                        }
@@ -6498,7 +6584,7 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
                                                  in->variant.hardLinkVariant.equivalentObjectId =
                                                    equivalentObjectId;
                                                  in->hardLinks.next =
                                                  in->variant.hardLinkVariant.equivalentObjectId =
                                                    equivalentObjectId;
                                                  in->hardLinks.next =
-                                                   (struct list_head *) hardList;
+                                                   (struct ylist_head *) hardList;
                                                  hardList = in;
                                                }
                                                break;
                                                  hardList = in;
                                                }
                                                break;
@@ -6558,27 +6644,27 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
        *  Sort out state of unlinked and deleted objects.
        */
        {
        *  Sort out state of unlinked and deleted objects.
        */
        {
-               struct list_head *i;
-               struct list_head *n;
+               struct ylist_head *i;
+               struct ylist_head *n;
 
                yaffs_Object *l;
 
                /* Soft delete all the unlinked files */
 
                yaffs_Object *l;
 
                /* Soft delete all the unlinked files */
-               list_for_each_safe(i, n,
+               ylist_for_each_safe(i, n,
                                   &dev->unlinkedDir->variant.directoryVariant.
                                   children) {
                        if (i) {
                                   &dev->unlinkedDir->variant.directoryVariant.
                                   children) {
                        if (i) {
-                               l = list_entry(i, yaffs_Object, siblings);
+                               l = ylist_entry(i, yaffs_Object, siblings);
                                yaffs_DestroyObject(l);
                        }
                }
 
                /* Soft delete all the deletedDir files */
                                yaffs_DestroyObject(l);
                        }
                }
 
                /* Soft delete all the deletedDir files */
-               list_for_each_safe(i, n,
+               ylist_for_each_safe(i, n,
                                   &dev->deletedDir->variant.directoryVariant.
                                   children) {
                        if (i) {
                                   &dev->deletedDir->variant.directoryVariant.
                                   children) {
                        if (i) {
-                               l = list_entry(i, yaffs_Object, siblings);
+                               l = ylist_entry(i, yaffs_Object, siblings);
                                yaffs_DestroyObject(l);
 
                        }
                                yaffs_DestroyObject(l);
 
                        }
@@ -6605,7 +6691,7 @@ static void yaffs_RemoveObjectFromDirectory(yaffs_Object * obj)
        if(dev && dev->removeObjectCallback)
                dev->removeObjectCallback(obj);
 
        if(dev && dev->removeObjectCallback)
                dev->removeObjectCallback(obj);
 
-       list_del_init(&obj->siblings);
+       ylist_del_init(&obj->siblings);
        obj->parent = NULL;
 }
 
        obj->parent = NULL;
 }
 
@@ -6631,14 +6717,14 @@ static void yaffs_AddObjectToDirectory(yaffs_Object * directory,
 
        if (obj->siblings.prev == NULL) {
                /* Not initialised */
 
        if (obj->siblings.prev == NULL) {
                /* Not initialised */
-               INIT_LIST_HEAD(&obj->siblings);
+               YINIT_LIST_HEAD(&obj->siblings);
 
 
-       } else if (!list_empty(&obj->siblings)) {
+       } else if (!ylist_empty(&obj->siblings)) {
                /* If it is holed up somewhere else, un hook it */
                yaffs_RemoveObjectFromDirectory(obj);
        }
        /* Now add it */
                /* If it is holed up somewhere else, un hook it */
                yaffs_RemoveObjectFromDirectory(obj);
        }
        /* Now add it */
-       list_add(&obj->siblings, &directory->variant.directoryVariant.children);
+       ylist_add(&obj->siblings, &directory->variant.directoryVariant.children);
        obj->parent = directory;
 
        if (directory == obj->myDev->unlinkedDir
        obj->parent = directory;
 
        if (directory == obj->myDev->unlinkedDir
@@ -6654,7 +6740,7 @@ yaffs_Object *yaffs_FindObjectByName(yaffs_Object * directory,
 {
        int sum;
 
 {
        int sum;
 
-       struct list_head *i;
+       struct ylist_head *i;
        YCHAR buffer[YAFFS_MAX_NAME_LENGTH + 1];
 
        yaffs_Object *l;
        YCHAR buffer[YAFFS_MAX_NAME_LENGTH + 1];
 
        yaffs_Object *l;
@@ -6679,9 +6765,9 @@ yaffs_Object *yaffs_FindObjectByName(yaffs_Object * directory,
 
        sum = yaffs_CalcNameSum(name);
 
 
        sum = yaffs_CalcNameSum(name);
 
-       list_for_each(i, &directory->variant.directoryVariant.children) {
+       ylist_for_each(i, &directory->variant.directoryVariant.children) {
                if (i) {
                if (i) {
-                       l = list_entry(i, yaffs_Object, siblings);
+                       l = ylist_entry(i, yaffs_Object, siblings);
 
                        yaffs_CheckObjectDetailsLoaded(l);
 
 
                        yaffs_CheckObjectDetailsLoaded(l);
 
@@ -6713,7 +6799,7 @@ yaffs_Object *yaffs_FindObjectByName(yaffs_Object * directory,
 int yaffs_ApplyToDirectoryChildren(yaffs_Object * theDir,
                                   int (*fn) (yaffs_Object *))
 {
 int yaffs_ApplyToDirectoryChildren(yaffs_Object * theDir,
                                   int (*fn) (yaffs_Object *))
 {
-       struct list_head *i;
+       struct ylist_head *i;
        yaffs_Object *l;
 
        if (!theDir) {
        yaffs_Object *l;
 
        if (!theDir) {
@@ -6730,9 +6816,9 @@ int yaffs_ApplyToDirectoryChildren(yaffs_Object * theDir,
                YBUG();
        }
 
                YBUG();
        }
 
-       list_for_each(i, &theDir->variant.directoryVariant.children) {
+       ylist_for_each(i, &theDir->variant.directoryVariant.children) {
                if (i) {
                if (i) {
-                       l = list_entry(i, yaffs_Object, siblings);
+                       l = ylist_entry(i, yaffs_Object, siblings);
                        if (l && !fn(l)) {
                                return YAFFS_FAIL;
                        }
                        if (l && !fn(l)) {
                                return YAFFS_FAIL;
                        }
@@ -6821,12 +6907,12 @@ int yaffs_GetObjectFileLength(yaffs_Object * obj)
 int yaffs_GetObjectLinkCount(yaffs_Object * obj)
 {
        int count = 0;
 int yaffs_GetObjectLinkCount(yaffs_Object * obj)
 {
        int count = 0;
-       struct list_head *i;
+       struct ylist_head *i;
 
        if (!obj->unlinked) {
                count++;        /* the object itself */
        }
 
        if (!obj->unlinked) {
                count++;        /* the object itself */
        }
-       list_for_each(i, &obj->hardLinks) {
+       ylist_for_each(i, &obj->hardLinks) {
                count++;        /* add the hard links; */
        }
        return count;
                count++;        /* add the hard links; */
        }
        return count;
@@ -7049,8 +7135,9 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
 
        /* Check geometry parameters. */
 
 
        /* Check geometry parameters. */
 
-       if ((dev->isYaffs2 && dev->nDataBytesPerChunk < 1024) ||
-           (!dev->isYaffs2 && dev->nDataBytesPerChunk != 512) ||
+       if ((!dev->inbandTags && dev->isYaffs2 && dev->totalBytesPerChunk < 1024) ||
+           (!dev->isYaffs2 && dev->totalBytesPerChunk != 512) ||
+           (dev->inbandTags && !dev->isYaffs2 ) ||
             dev->nChunksPerBlock < 2 ||
             dev->nReservedBlocks < 2 ||
             dev->internalStartBlock <= 0 ||
             dev->nChunksPerBlock < 2 ||
             dev->nReservedBlocks < 2 ||
             dev->internalStartBlock <= 0 ||
@@ -7059,8 +7146,8 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
            ) {
                T(YAFFS_TRACE_ALWAYS,
                  (TSTR
            ) {
                T(YAFFS_TRACE_ALWAYS,
                  (TSTR
-                  ("yaffs: NAND geometry problems: chunk size %d, type is yaffs%s "
-                   TENDSTR), dev->nDataBytesPerChunk, dev->isYaffs2 ? "2" : ""));
+                  ("yaffs: NAND geometry problems: chunk size %d, type is yaffs%s, inbandTags %d "
+                   TENDSTR), dev->totalBytesPerChunk, dev->isYaffs2 ? "2" : "", dev->inbandTags));
                return YAFFS_FAIL;
        }
 
                return YAFFS_FAIL;
        }
 
@@ -7069,6 +7156,12 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
                  (TSTR("yaffs: InitialiseNAND failed" TENDSTR)));
                return YAFFS_FAIL;
        }
                  (TSTR("yaffs: InitialiseNAND failed" TENDSTR)));
                return YAFFS_FAIL;
        }
+       
+       /* Sort out space for inband tags, if required */
+       if(dev->inbandTags)
+               dev->nDataBytesPerChunk = dev->totalBytesPerChunk - sizeof(yaffs_PackedTags2TagsPart);
+       else 
+               dev->nDataBytesPerChunk = dev->totalBytesPerChunk;
 
        /* Got the right mix of functions? */
        if (!yaffs_CheckDevFunctions(dev)) {
 
        /* Got the right mix of functions? */
        if (!yaffs_CheckDevFunctions(dev)) {
@@ -7104,22 +7197,14 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
        /*
         *  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);
-        dev->chunkMask = (1<<dev->chunkShift) - 1;
-
-        if(dev->nDataBytesPerChunk == (dev->chunkMask + 1)){
-               /* Yes it is a power of 2, disable crumbs */
-               dev->crumbMask = 0;
-               dev->crumbShift = 0;
-               dev->crumbsPerChunk = 0;
-        } else {
-               /* Not a power of 2, use crumbs instead */
-               dev->crumbShift = ShiftDiv(sizeof(yaffs_PackedTags2TagsPart));
-               dev->crumbMask = (1<<dev->crumbShift)-1;
-               dev->crumbsPerChunk = dev->nDataBytesPerChunk/(1 << dev->crumbShift);
-               dev->chunkShift = 0;
-               dev->chunkMask = 0;
+        {
+               __u32 x = dev->nDataBytesPerChunk;
+                /* We always use dev->chunkShift and dev->chunkDiv */
+                dev->chunkShift = Shifts(x);
+                x >>= dev->chunkShift;
+                dev->chunkDiv = x;
+                /* We only use chunk mask if chunkDiv is 1 */
+                dev->chunkMask = (1<<dev->chunkShift) - 1;
        }
 
 
        }
 
 
@@ -7203,7 +7288,7 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
        if (!init_failed &&
            dev->nShortOpCaches > 0) {
                int i;
        if (!init_failed &&
            dev->nShortOpCaches > 0) {
                int i;
-               __u8 *buf;
+               void *buf;
                int srCacheBytes = dev->nShortOpCaches * sizeof(yaffs_ChunkCache);
 
                if (dev->nShortOpCaches > YAFFS_MAX_SHORT_OP_CACHES) {
                int srCacheBytes = dev->nShortOpCaches * sizeof(yaffs_ChunkCache);
 
                if (dev->nShortOpCaches > YAFFS_MAX_SHORT_OP_CACHES) {
@@ -7219,7 +7304,7 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
                        dev->srCache[i].object = NULL;
                        dev->srCache[i].lastUse = 0;
                        dev->srCache[i].dirty = 0;
                        dev->srCache[i].object = NULL;
                        dev->srCache[i].lastUse = 0;
                        dev->srCache[i].dirty = 0;
-                       dev->srCache[i].data = buf = YMALLOC_DMA(dev->nDataBytesPerChunk);
+                       dev->srCache[i].data = buf = YMALLOC_DMA(dev->totalBytesPerChunk);
                }
                if(!buf)
                        init_failed = 1;
                }
                if(!buf)
                        init_failed = 1;
@@ -7345,6 +7430,7 @@ void yaffs_Deinitialise(yaffs_Device * dev)
                        YFREE(dev->tempBuffer[i].buffer);
                }
 
                        YFREE(dev->tempBuffer[i].buffer);
                }
 
+
                dev->isMounted = 0;
        }
 
                dev->isMounted = 0;
        }
 
@@ -7410,7 +7496,7 @@ int yaffs_GetNumberOfFreeChunks(yaffs_Device * dev)
        nFree -= ((dev->nReservedBlocks + 1) * dev->nChunksPerBlock);
 
        /* Now we figure out how much to reserve for the checkpoint and report that... */
        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;
+       blocksForCheckpoint = yaffs_CalcCheckpointBlocksRequired(dev) - dev->blocksInCheckpoint;
        if(blocksForCheckpoint < 0)
                blocksForCheckpoint = 0;
 
        if(blocksForCheckpoint < 0)
                blocksForCheckpoint = 0;
 
@@ -7448,22 +7534,25 @@ static void yaffs_VerifyFreeChunks(yaffs_Device * dev)
 /*---------------------------------------- YAFFS test code ----------------------*/
 
 #define yaffs_CheckStruct(structure,syze, name) \
 /*---------------------------------------- YAFFS test code ----------------------*/
 
 #define yaffs_CheckStruct(structure,syze, name) \
+       do { \
            if(sizeof(structure) != syze) \
               { \
                 T(YAFFS_TRACE_ALWAYS,(TSTR("%s should be %d but is %d\n" TENDSTR),\
                 name,syze,sizeof(structure))); \
                 return YAFFS_FAIL; \
            if(sizeof(structure) != syze) \
               { \
                 T(YAFFS_TRACE_ALWAYS,(TSTR("%s should be %d but is %d\n" TENDSTR),\
                 name,syze,sizeof(structure))); \
                 return YAFFS_FAIL; \
-               }
+               } \
+       } while(0)
 
 static int yaffs_CheckStructures(void)
 {
 
 static int yaffs_CheckStructures(void)
 {
-/*      yaffs_CheckStruct(yaffs_Tags,8,"yaffs_Tags") */
-/*      yaffs_CheckStruct(yaffs_TagsUnion,8,"yaffs_TagsUnion") */
-/*      yaffs_CheckStruct(yaffs_Spare,16,"yaffs_Spare") */
+/*      yaffs_CheckStruct(yaffs_Tags,8,"yaffs_Tags"); */
+/*      yaffs_CheckStruct(yaffs_TagsUnion,8,"yaffs_TagsUnion"); */
+/*      yaffs_CheckStruct(yaffs_Spare,16,"yaffs_Spare"); */
 #ifndef CONFIG_YAFFS_TNODE_LIST_DEBUG
 #ifndef CONFIG_YAFFS_TNODE_LIST_DEBUG
-       yaffs_CheckStruct(yaffs_Tnode, 2 * YAFFS_NTNODES_LEVEL0, "yaffs_Tnode")
+       yaffs_CheckStruct(yaffs_Tnode, 2 * YAFFS_NTNODES_LEVEL0, "yaffs_Tnode");
+#endif
+#ifndef CONFIG_YAFFS_WINCE
+               yaffs_CheckStruct(yaffs_ObjectHeader, 512, "yaffs_ObjectHeader");
 #endif
 #endif
-           yaffs_CheckStruct(yaffs_ObjectHeader, 512, "yaffs_ObjectHeader")
-
            return YAFFS_OK;
 }
            return YAFFS_OK;
 }
Personal OpenWRT clone
This page took 0.072195 seconds and 4 git commands to generate.