*/
const char *yaffs_guts_c_version =
- "$Id: yaffs_guts.c,v 1.98 2009-12-07 01:17:33 charles Exp $";
+ "$Id: yaffs_guts.c,v 1.107 2010-02-17 02:01:25 charles Exp $";
#include "yportenv.h"
+#include "yaffs_trace.h"
#include "yaffsinterface.h"
#include "yaffs_guts.h"
yaffs_FileStructure *fStruct,
__u32 chunkId);
+static void yaffs_SkipRestOfBlock(yaffs_Device *dev);
+static int yaffs_VerifyChunkWritten(yaffs_Device *dev,
+ int chunkInNAND,
+ const __u8 *data,
+ yaffs_ExtendedTags *tags);
+
/* Function to calculate chunk and offset */
static void yaffs_AddrToChunk(yaffs_Device *dev, loff_t addr, int *chunkOut,
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));
+ (TSTR("Verifying object header tags %p obj %p oh %p"TENDSTR),
+ tags, obj, oh));
return;
}
}
+
+static int yaffs_VerifyChunkWritten(yaffs_Device *dev,
+ int chunkInNAND,
+ const __u8 *data,
+ yaffs_ExtendedTags *tags)
+{
+ int retval = YAFFS_OK;
+ yaffs_ExtendedTags tempTags;
+ __u8 *buffer = yaffs_GetTempBuffer(dev,__LINE__);
+ int result;
+
+ result = yaffs_ReadChunkWithTagsFromNAND(dev,chunkInNAND,buffer,&tempTags);
+ if(memcmp(buffer,data,dev->nDataBytesPerChunk) ||
+ tempTags.objectId != tags->objectId ||
+ tempTags.chunkId != tags->chunkId ||
+ tempTags.byteCount != tags->byteCount)
+ retval = YAFFS_FAIL;
+
+ yaffs_ReleaseTempBuffer(dev, buffer, __LINE__);
+
+ return retval;
+}
+
static int yaffs_WriteNewChunkWithTagsToNAND(struct yaffs_DeviceStruct *dev,
const __u8 *data,
yaffs_ExtendedTags *tags,
* chunk due to power loss. This checking policy should
* catch that case with very few checks and thus save a
* lot of checks that are most likely not needed.
+ *
+ * Mods to the above
+ * If an erase check fails or the write fails we skip the
+ * rest of the block.
*/
- if (bi->gcPrioritise) {
- yaffs_DeleteChunk(dev, chunk, 1, __LINE__);
- /* try another chunk */
- continue;
- }
/* let's give it a try */
attempts++;
(TSTR("**>> yaffs chunk %d was not erased"
TENDSTR), chunk));
- /* try another chunk */
+ /* If not erased, delete this one,
+ * skip rest of block and
+ * try another chunk */
+ yaffs_DeleteChunk(dev,chunk,1,__LINE__);
+ yaffs_SkipRestOfBlock(dev);
continue;
}
- bi->skipErasedCheck = 1;
}
writeOk = yaffs_WriteChunkWithTagsToNAND(dev, chunk,
data, tags);
+
+ if(!bi->skipErasedCheck)
+ writeOk = yaffs_VerifyChunkWritten(dev, chunk, data, tags);
+
if (writeOk != YAFFS_OK) {
+ /* Clean up aborted write, skip to next block and
+ * try another chunk */
yaffs_HandleWriteChunkError(dev, chunk, erasedOk);
- /* try another chunk */
continue;
}
+ bi->skipErasedCheck = 1;
+
/* Copy the data into the robustification buffer */
yaffs_HandleWriteChunkOk(dev, chunk, data, tags);
/* Delete the chunk */
yaffs_DeleteChunk(dev, chunkInNAND, 1, __LINE__);
+ yaffs_SkipRestOfBlock(dev);
}
* adds them to the tnode free list.
* Don't use this function directly
*/
+static Y_INLINE int yaffs_CalcTnodeSize(yaffs_Device *dev)
+{
+ int tnodeSize;
+ /* Calculate the tnode size in bytes for variable width tnode support.
+ * Must be a multiple of 32-bits */
+ tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
+
+ if (tnodeSize < sizeof(yaffs_Tnode))
+ tnodeSize = sizeof(yaffs_Tnode);
+ return tnodeSize;
+}
static int yaffs_CreateTnodes(yaffs_Device *dev, int nTnodes)
{
int i;
- int tnodeSize;
+ int tnodeSize = yaffs_CalcTnodeSize(dev);
yaffs_Tnode *newTnodes;
__u8 *mem;
yaffs_Tnode *curr;
if (nTnodes < 1)
return YAFFS_OK;
- /* Calculate the tnode size in bytes for variable width tnode support.
- * Must be a multiple of 32-bits */
- tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
-
- if (tnodeSize < sizeof(yaffs_Tnode))
- tnodeSize = sizeof(yaffs_Tnode);
/* make these things */
{
yaffs_Tnode *tn = NULL;
+#ifdef CONFIG_YAFFS_VALGRIND_TEST
+ tn = YMALLOC(yaffs_CalcTnodeSize(dev));
+ if(tn)
+ dev->nTnodesCreated++;
+#else
/* If there are none left make more */
if (!dev->freeTnodes)
yaffs_CreateTnodes(dev, YAFFS_ALLOCATION_NTNODES);
dev->freeTnodes = dev->freeTnodes->internal[0];
dev->nFreeTnodes--;
}
-
+#endif
dev->nCheckpointBlocksRequired = 0; /* force recalculation*/
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);
+ int tnodeSize = yaffs_CalcTnodeSize(dev);
if (tn)
memset(tn, 0, tnodeSize);
static void yaffs_FreeTnode(yaffs_Device *dev, yaffs_Tnode *tn)
{
if (tn) {
+#ifdef CONFIG_YAFFS_VALGRIND_TEST
+ YFREE(tn);
+ dev->nTnodesCreated--;
+#else
#ifdef CONFIG_YAFFS_TNODE_LIST_DEBUG
if (tn->internal[YAFFS_NTNODES_INTERNAL] != 0) {
/* Hoosterman, this thing looks like it is already in the list */
tn->internal[0] = dev->freeTnodes;
dev->freeTnodes = tn;
dev->nFreeTnodes++;
+#endif
}
dev->nCheckpointBlocksRequired = 0; /* force recalculation*/
}
dev->freeTnodes = NULL;
dev->nFreeTnodes = 0;
+ dev->nTnodesCreated = 0;
}
static void yaffs_InitialiseTnodes(yaffs_Device *dev)
tn->internal[x] = yaffs_GetTnode(dev);
if(!tn->internal[x])
return NULL;
-
} else if (l == 1) {
/* Looking from level 1 at level 0 */
if (passedTn) {
* level 0 tnode entries must be zeroed out.
* Could also use this for file deletion, but that's probably better handled
* by a special case.
+ *
+ * This function is recursive. For levels > 0 the function is called again on
+ * any sub-tree. For level == 0 we just check if the sub-tree has data.
+ * If there is no data in a subtree then it is pruned.
*/
static yaffs_Tnode *yaffs_PruneWorker(yaffs_Device *dev, yaffs_Tnode *tn,
if (tn) {
hasData = 0;
- for (i = 0; i < YAFFS_NTNODES_INTERNAL; i++) {
- if (tn->internal[i] && level > 0) {
- tn->internal[i] =
- yaffs_PruneWorker(dev, tn->internal[i],
- level - 1,
- (i == 0) ? del0 : 1);
+ if(level > 0){
+ for (i = 0; i < YAFFS_NTNODES_INTERNAL; i++) {
+ if (tn->internal[i]) {
+ tn->internal[i] =
+ yaffs_PruneWorker(dev, tn->internal[i],
+ level - 1,
+ (i == 0) ? del0 : 1);
+ }
+
+ if (tn->internal[i])
+ hasData++;
}
+ } else {
+ int tnodeSize_u32 = yaffs_CalcTnodeSize(dev)/sizeof(__u32);
+ __u32 *map = (__u32 *)tn;
- if (tn->internal[i])
- hasData++;
- }
+ for(i = 0; !hasData && i < tnodeSize_u32; i++){
+ if(map[i])
+ hasData++;
+ }
+ }
if (hasData == 0 && del0) {
/* Free and return NULL */
{
yaffs_Object *tn = NULL;
-#ifdef VALGRIND_TEST
+#ifdef CONFIG_YAFFS_VALGRIND_TEST
tn = YMALLOC(sizeof(yaffs_Object));
+ if(tn)
+ dev->nObjectsCreated++;
#else
/* If there are none left make more */
if (!dev->freeObjects)
{
yaffs_Device *dev = tn->myDev;
-#ifdef __KERNEL__
T(YAFFS_TRACE_OS, (TSTR("FreeObject %p inode %p"TENDSTR), tn, tn->myInode));
-#endif
+ if (!tn)
+ YBUG();
if (tn->parent)
YBUG();
if (!ylist_empty(&tn->siblings))
YBUG();
-#ifdef __KERNEL__
if (tn->myInode) {
/* We're still hooked up to a cached inode.
* Don't delete now, but mark for later deletion
tn->deferedFree = 1;
return;
}
-#endif
yaffs_UnhashObject(tn);
-#ifdef VALGRIND_TEST
+#ifdef CONFIG_YAFFS_VALGRIND_TEST
YFREE(tn);
+ dev->nObjectsCreated--;
tn = NULL;
#else
/* Link into the free list. */
dev->freeObjects = NULL;
dev->nFreeObjects = 0;
+ dev->nObjectsCreated = 0;
}
static void yaffs_InitialiseObjects(yaffs_Device *dev)
yaffs_Object *yaffs_CreateNewObject(yaffs_Device *dev, int number,
yaffs_ObjectType type)
{
- yaffs_Object *theObject;
+ yaffs_Object *theObject=NULL;
yaffs_Tnode *tn = NULL;
if (number < 0)
+
if (in) {
in->hdrChunk = 0;
in->valid = 1;
int nBytes = 0;
int nBlocks;
int devBlocks = (dev->endBlock - dev->startBlock + 1);
- int tnodeSize;
-
- tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
-
- if (tnodeSize < sizeof(yaffs_Tnode))
- tnodeSize = sizeof(yaffs_Tnode);
+ int tnodeSize = yaffs_CalcTnodeSize(dev);
nBytes += sizeof(yaffs_CheckpointValidity);
nBytes += sizeof(yaffs_CheckpointDevice);
}
+/*
+ * yaffs_SkipRestOfBlock() skips over the rest of the allocation block
+ * if we don't want to write to it.
+ */
+static void yaffs_SkipRestOfBlock(yaffs_Device *dev)
+{
+ if(dev->allocationBlock > 0){
+ yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, dev->allocationBlock);
+ if(bi->blockState == YAFFS_BLOCK_STATE_ALLOCATING){
+ bi->blockState = YAFFS_BLOCK_STATE_FULL;
+ dev->allocationBlock = -1;
+ }
+ }
+}
+
+
static int yaffs_GarbageCollectBlock(yaffs_Device *dev, int block,
int wholeBlock)
{
object->serial = tags.serialNumber;
} else {
/* It's a data chunk */
- yaffs_PutChunkIntoFile
+ int ok;
+ ok = yaffs_PutChunkIntoFile
(object,
tags.chunkId,
newChunk, 0);
if(!chunkInNAND)
/* Dummy insert, bail now */
return YAFFS_OK;
-
existingChunk = yaffs_GetChunkGroupBase(dev, tn, chunkInInode);
yaffs_CheckGarbageCollection(dev);
- /* Get the previous chunk at this location in the file if it exists */
+ /* Get the previous chunk at this location in the file if it exists.
+ * If it does not exist then put a zero into the tree. This creates
+ * the tnode now, rather than later when it is harder to clean up.
+ */
prevChunkId = yaffs_FindChunkInFile(in, chunkInInode, &prevTags);
+ if(prevChunkId <= 0 &&
+ !yaffs_PutChunkIntoFile(in, chunkInInode, 0, 0)){
+ }
/* Set up new tags */
yaffs_InitialiseTags(&newTags);
int i;
yaffs_Device *dev = in->myDev;
int ok = 1;
- int tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
-
- if (tnodeSize < sizeof(yaffs_Tnode))
- tnodeSize = sizeof(yaffs_Tnode);
-
+ int tnodeSize = yaffs_CalcTnodeSize(dev);
if (tn) {
if (level > 0) {
yaffs_FileStructure *fileStructPtr = &obj->variant.fileVariant;
yaffs_Tnode *tn;
int nread = 0;
- int tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
-
- if (tnodeSize < sizeof(yaffs_Tnode))
- tnodeSize = sizeof(yaffs_Tnode);
+ int tnodeSize = yaffs_CalcTnodeSize(dev);
ok = (yaffs_CheckpointRead(dev, &baseChunk, sizeof(baseChunk)) == sizeof(baseChunk));
cp.structType = sizeof(cp);
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.hdrChunk, (unsigned) obj));
+ TSTR("Checkpoint write object %d parent %d type %d chunk %d obj addr %p" TENDSTR),
+ cp.objectId, cp.parentId, cp.variantType, cp.hdrChunk, obj));
ok = (yaffs_CheckpointWrite(dev, &cp, sizeof(cp)) == sizeof(cp));
ok = (yaffs_CheckpointRead(dev, &cp, sizeof(cp)) == sizeof(cp));
if (cp.structType != sizeof(cp)) {
T(YAFFS_TRACE_CHECKPOINT, (TSTR("struct size %d instead of %d ok %d"TENDSTR),
- cp.structType, sizeof(cp), ok));
+ cp.structType, (int)sizeof(cp), ok));
ok = 0;
}
int retVal;
int immediateDeletion = 0;
-#ifdef __KERNEL__
if (!in->myInode)
immediateDeletion = 1;
-#else
- if (in->inUse <= 0)
- immediateDeletion = 1;
-#endif
if (immediateDeletion) {
retVal =
int immediateDeletion = 0;
-#ifdef __KERNEL__
if (!obj->myInode)
immediateDeletion = 1;
-#else
- if (obj->inUse <= 0)
- immediateDeletion = 1;
-#endif
if(obj)
yaffs_UpdateParent(obj->parent);
* Instead, we do the following:
* - Select a hardlink.
* - Unhook it from the hard links
- * - Unhook it from its parent directory (so that the rename can work)
+ * - Move it from its parent directory (so that the rename can work)
* - Rename the object to the hardlink's name.
* - Delete the hardlink
*/
yaffs_Object *hl;
+ yaffs_Object *parent;
int retVal;
YCHAR name[YAFFS_MAX_NAME_LENGTH + 1];
hl = ylist_entry(obj->hardLinks.next, yaffs_Object, hardLinks);
+ yaffs_GetObjectName(hl, name, YAFFS_MAX_NAME_LENGTH + 1);
+ parent = hl->parent;
+
ylist_del_init(&hl->hardLinks);
- ylist_del_init(&hl->siblings);
- yaffs_GetObjectName(hl, name, YAFFS_MAX_NAME_LENGTH + 1);
+ yaffs_AddObjectToDirectory(obj->myDev->unlinkedDir, hl);
- retVal = yaffs_ChangeObjectName(obj, hl->parent, name, 0, 0);
+ retVal = yaffs_ChangeObjectName(obj,parent, name, 0, 0);
if (retVal == YAFFS_OK)
retVal = yaffs_DoGenericObjectDeletion(hl);
dev->allocationBlock = blk;
dev->allocationPage = c;
dev->allocationBlockFinder = blk;
- /* Set it to here to encourage the allocator to go forth from here. */
+ /* Set block finder here to encourage the allocator to go forth from here. */
}
break;
}
-/*
- if (parent == dev->deletedDir) {
- yaffs_DestroyObject(in);
- bi->hasShrinkHeader = 1;
- }
-*/
}
}
}
state = YAFFS_BLOCK_STATE_FULL;
}
+ if (state == YAFFS_BLOCK_STATE_ALLOCATING) {
+ /* If the block was partially allocated then treat it as fully allocated.*/
+ state = YAFFS_BLOCK_STATE_FULL;
+ dev->allocationBlock = -1;
+ }
+
bi->blockState = state;
/* Now let's see if it was dirty */
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.
+ * the current allocation block.
*/
- /* bi->needsRetiring = 1; ??? TODO */
- bi->gcPrioritise = 1;
-
T(YAFFS_TRACE_ALWAYS,
(TSTR("Partially written block %d detected" TENDSTR),
blk));
oh->
shadowsObject,
1);
+
yaffs_SetObjectName(in, oh->name);
state = YAFFS_BLOCK_STATE_FULL;
}
+
bi->blockState = state;
/* Now let's see if it was dirty */
}
}
+
+ yaffs_SkipRestOfBlock(dev);
if (altBlockIndex)
YFREE_ALT(blockIndex);
do { \
if (sizeof(structure) != syze) { \
T(YAFFS_TRACE_ALWAYS, (TSTR("%s should be %d but is %d\n" TENDSTR),\
- name, syze, sizeof(structure))); \
+ name, syze, (int) sizeof(structure))); \
return YAFFS_FAIL; \
} \
} while (0)
/* yaffs_CheckStruct(yaffs_TagsUnion,8,"yaffs_TagsUnion"); */
/* yaffs_CheckStruct(yaffs_Spare,16,"yaffs_Spare"); */
#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");
projects / yaffs2.git / blobdiff