* published by the Free Software Foundation.
*/
-
const char *yaffs_guts_c_version =
- "$Id: yaffs_guts.c,v 1.74 2009-01-18 23:24:08 charles Exp $";
+ "$Id: yaffs_guts.c,v 1.80 2009-03-05 21:46:46 charles Exp $";
#include "yportenv.h"
#include "yaffs_packedtags2.h"
-#ifdef CONFIG_YAFFS_WINCE
-void yfsd_LockYAFFS(BOOL fsLockOnly);
-void yfsd_UnlockYAFFS(BOOL fsLockOnly);
-#endif
-
#define YAFFS_PASSIVE_GC_CHUNKS 2
#include "yaffs_ecc.h"
int chunkInNAND);
static int yaffs_UnlinkWorker(yaffs_Object * obj);
-static void yaffs_DestroyObject(yaffs_Object * obj);
static int yaffs_TagsMatch(const yaffs_ExtendedTags * tags, int objectId,
int chunkInObject);
yaffs_InvalidateCheckpoint(dev);
- yaffs_MarkBlockBad(dev, blockInNAND);
+ if (yaffs_MarkBlockBad(dev, blockInNAND) != YAFFS_OK) {
+ if (yaffs_EraseBlockInNAND(dev, blockInNAND) != YAFFS_OK) {
+ T(YAFFS_TRACE_ALWAYS, (TSTR(
+ "yaffs: Failed to mark bad and erase block %d"
+ TENDSTR), blockInNAND));
+ }
+ else {
+ yaffs_ExtendedTags tags;
+ int chunkId = blockInNAND * dev->nChunksPerBlock;
+
+ __u8 *buffer = yaffs_GetTempBuffer(dev, __LINE__);
+
+ memset(buffer, 0xff, dev->nDataBytesPerChunk);
+ yaffs_InitialiseTags(&tags);
+ tags.sequenceNumber = YAFFS_SEQUENCE_BAD_BLOCK;
+ if (dev->writeChunkWithTagsToNAND(dev, chunkId -
+ dev->chunkOffset, buffer, &tags) != YAFFS_OK)
+ T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: Failed to "
+ TCONT("write bad block marker to block %d")
+ TENDSTR), blockInNAND));
+
+ yaffs_ReleaseTempBuffer(dev, buffer, __LINE__);
+ }
+ }
bi->blockState = YAFFS_BLOCK_STATE_DEAD;
bi->gcPrioritise = 0;
bname++;
}
}
-
return sum;
}
yaffs_Device *dev = tn->myDev;
+#ifdef __KERNEL__
+ T(YAFFS_TRACE_OS,(TSTR("FreeObject %p inode %p"TENDSTR),tn,tn->myInode));
+#endif
if(tn->parent)
YBUG();
theObject->yst_atime = theObject->yst_mtime =
theObject->yst_ctime = Y_CURRENT_TIME;
#endif
-
-#if 0
- theObject->sum_prev = 12345;
- theObject->sum_trailer = 6789;
-#endif
-
switch (type) {
case YAFFS_OBJECT_TYPE_FILE:
theObject->variant.fileVariant.fileSize = 0;
if (yaffs_UpdateObjectHeader(in, name, 0, 0, 0) < 0) {
/* Could not create the object header, fail the creation */
- yaffs_DestroyObject(in);
+ yaffs_DeleteObject(in);
in = NULL;
}
* We need to nuke the shrinkheader flags first
* We no longer want the shrinkHeader flag since its work is done
* and if it is left in place it will mess up scanning.
- * Also, clear out any shadowing stuff
*/
yaffs_ObjectHeader *oh;
oh = (yaffs_ObjectHeader *)buffer;
oh->isShrink = 0;
- tags.extraShadows = 0;
tags.extraIsShrinkHeader = 0;
yaffs_VerifyObjectHeader(object,oh,&tags,1);
}
yaffs_ReleaseTempBuffer(dev, buffer, __LINE__);
-
/* Do any required cleanups */
if(nBytes < 1 || nBytes > dev->totalBytesPerChunk){
T(YAFFS_TRACE_ERROR,
(TSTR("Writing %d bytes to chunk!!!!!!!!!" TENDSTR), nBytes));
- while(1){}
- }
+ YBUG();
+ }
cp->fileSizeOrEquivalentObjectId = obj->variant.hardLinkVariant.equivalentObjectId;
}
-static void yaffs_CheckpointObjectToObject( yaffs_Object *obj,yaffs_CheckpointObject *cp)
+static int yaffs_CheckpointObjectToObject( yaffs_Object *obj,yaffs_CheckpointObject *cp)
{
yaffs_Object *parent;
+
+ if (obj->variantType != cp->variantType) {
+ T(YAFFS_TRACE_ERROR,(TSTR("Checkpoint read object %d type %d "
+ TCONT("chunk %d does not match existing object type %d")
+ TENDSTR), cp->objectId, cp->variantType, cp->hdrChunk,
+ obj->variantType));
+ return 0;
+ }
obj->objectId = cp->objectId;
else
parent = NULL;
- if(parent)
+ if(parent) {
+ if (parent->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) {
+ T(YAFFS_TRACE_ALWAYS,(TSTR("Checkpoint read object %d parent %d type %d"
+ TCONT(" chunk %d Parent type, %d, not directory")
+ TENDSTR),
+ cp->objectId,cp->parentId,cp->variantType,cp->hdrChunk,parent->variantType));
+ return 0;
+ }
yaffs_AddObjectToDirectory(parent, obj);
+ }
obj->hdrChunk = cp->hdrChunk;
obj->variantType = cp->variantType;
if(obj->hdrChunk > 0)
obj->lazyLoaded = 1;
+ return 1;
}
else if(ok){
obj = yaffs_FindOrCreateObjectByNumber(dev,cp.objectId, cp.variantType);
if(obj) {
- yaffs_CheckpointObjectToObject(obj,&cp);
+ ok = yaffs_CheckpointObjectToObject(obj,&cp);
+ if (!ok)
+ break;
if(obj->variantType == YAFFS_OBJECT_TYPE_FILE) {
ok = yaffs_ReadCheckpointTnodes(obj);
} else if(obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) {
}
}
+ else
+ ok = 0;
}
}
cache->locked = 1;
-#ifdef CONFIG_YAFFS_WINCE
- yfsd_UnlockYAFFS(TRUE);
-#endif
+
memcpy(buffer, &cache->data[start], nToCopy);
-#ifdef CONFIG_YAFFS_WINCE
- yfsd_LockYAFFS(TRUE);
-#endif
cache->locked = 0;
} else {
/* Read into the local buffer then copy..*/
yaffs_GetTempBuffer(dev, __LINE__);
yaffs_ReadChunkDataFromObject(in, chunk,
localBuffer);
-#ifdef CONFIG_YAFFS_WINCE
- yfsd_UnlockYAFFS(TRUE);
-#endif
+
memcpy(buffer, &localBuffer[start], nToCopy);
-#ifdef CONFIG_YAFFS_WINCE
- yfsd_LockYAFFS(TRUE);
-#endif
+
yaffs_ReleaseTempBuffer(dev, localBuffer,
__LINE__);
}
} else {
-#ifdef CONFIG_YAFFS_WINCE
- __u8 *localBuffer = yaffs_GetTempBuffer(dev, __LINE__);
- /* Under WinCE can't do direct transfer. Need to use a local buffer.
- * This is because we otherwise screw up WinCE's memory mapper
- */
- yaffs_ReadChunkDataFromObject(in, chunk, localBuffer);
-
-#ifdef CONFIG_YAFFS_WINCE
- yfsd_UnlockYAFFS(TRUE);
-#endif
- memcpy(buffer, localBuffer, dev->nDataBytesPerChunk);
-
-#ifdef CONFIG_YAFFS_WINCE
- yfsd_LockYAFFS(TRUE);
- yaffs_ReleaseTempBuffer(dev, localBuffer, __LINE__);
-#endif
-
-#else
/* A full chunk. Read directly into the supplied buffer. */
yaffs_ReadChunkDataFromObject(in, chunk, buffer);
-#endif
+
}
n -= nToCopy;
if(chunk * dev->nDataBytesPerChunk + start != offset ||
start >= dev->nDataBytesPerChunk){
- T(YAFFS_TRACE_ERROR,(TSTR("AddrToChunk of offset %d gives chunk %d start %d"TENDSTR),
- (int)offset, chunk,start));
+ T(YAFFS_TRACE_ERROR,(
+ TSTR("AddrToChunk of offset %d gives chunk %d start %d"
+ TENDSTR),
+ (int)offset, chunk,start));
}
chunk++;
if (cache) {
yaffs_UseChunkCache(dev, cache, 1);
cache->locked = 1;
-#ifdef CONFIG_YAFFS_WINCE
- yfsd_UnlockYAFFS(TRUE);
-#endif
+
memcpy(&cache->data[start], buffer,
nToCopy);
-#ifdef CONFIG_YAFFS_WINCE
- yfsd_LockYAFFS(TRUE);
-#endif
+
cache->locked = 0;
cache->nBytes = nToWriteBack;
yaffs_ReadChunkDataFromObject(in, chunk,
localBuffer);
-#ifdef CONFIG_YAFFS_WINCE
- yfsd_UnlockYAFFS(TRUE);
-#endif
+
memcpy(&localBuffer[start], buffer, nToCopy);
-#ifdef CONFIG_YAFFS_WINCE
- yfsd_LockYAFFS(TRUE);
-#endif
chunkWritten =
yaffs_WriteChunkDataToObject(in, chunk,
localBuffer,
} 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
- */
- __u8 *localBuffer = yaffs_GetTempBuffer(dev, __LINE__);
-#ifdef CONFIG_YAFFS_WINCE
- yfsd_UnlockYAFFS(TRUE);
-#endif
- memcpy(localBuffer, buffer, dev->nDataBytesPerChunk);
-#ifdef CONFIG_YAFFS_WINCE
- yfsd_LockYAFFS(TRUE);
-#endif
- chunkWritten =
- yaffs_WriteChunkDataToObject(in, chunk, localBuffer,
- dev->nDataBytesPerChunk,
- 0);
- yaffs_ReleaseTempBuffer(dev, localBuffer, __LINE__);
-#else
+
chunkWritten =
yaffs_WriteChunkDataToObject(in, chunk, buffer,
dev->nDataBytesPerChunk,
0);
-#endif
+
/* Since we've overwritten the cached data, we better invalidate it. */
yaffs_InvalidateChunkCache(in, chunk);
}
* and the inode associated with the file.
* It does not delete the links associated with the file.
*/
-
-static int yaffs_UnlinkFile(yaffs_Object * in)
+static int yaffs_UnlinkFileIfNeeded(yaffs_Object * in)
{
int retVal;
* That won't be the case if it has been resized to zero.
*/
if (!in->unlinked) {
- retVal = yaffs_UnlinkFile(in);
+ retVal = yaffs_UnlinkFileIfNeeded(in);
}
if (retVal == YAFFS_OK && in->unlinked && !in->deleted) {
in->deleted = deleted = 1;
return yaffs_DoGenericObjectDeletion(in);
}
-static void yaffs_DestroyObject(yaffs_Object * obj)
+int yaffs_DeleteObject(yaffs_Object * obj)
{
+int retVal = -1;
switch (obj->variantType) {
case YAFFS_OBJECT_TYPE_FILE:
- yaffs_DeleteFile(obj);
+ retVal = yaffs_DeleteFile(obj);
break;
case YAFFS_OBJECT_TYPE_DIRECTORY:
- yaffs_DeleteDirectory(obj);
+ return yaffs_DeleteDirectory(obj);
break;
case YAFFS_OBJECT_TYPE_SYMLINK:
- yaffs_DeleteSymLink(obj);
+ retVal = yaffs_DeleteSymLink(obj);
break;
case YAFFS_OBJECT_TYPE_HARDLINK:
- yaffs_DeleteHardLink(obj);
+ retVal = yaffs_DeleteHardLink(obj);
break;
case YAFFS_OBJECT_TYPE_SPECIAL:
- yaffs_DoGenericObjectDeletion(obj);
+ retVal = yaffs_DoGenericObjectDeletion(obj);
break;
case YAFFS_OBJECT_TYPE_UNKNOWN:
+ retVal = 0;
break; /* should not happen. */
}
+
+ return retVal;
}
static int yaffs_UnlinkWorker(yaffs_Object * obj)
{
+ int immediateDeletion = 0;
+
+#ifdef __KERNEL__
+ if (!obj->myInode) {
+ immediateDeletion = 1;
+ }
+#else
+ if (obj->inUse <= 0) {
+ immediateDeletion = 1;
+ }
+#endif
+
if (obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) {
return yaffs_DeleteHardLink(obj);
} else if (!ylist_empty(&obj->hardLinks)) {
}
return retVal;
- } else {
+ } else if(immediateDeletion){
switch (obj->variantType) {
case YAFFS_OBJECT_TYPE_FILE:
- return yaffs_UnlinkFile(obj);
+ return yaffs_DeleteFile(obj);
break;
case YAFFS_OBJECT_TYPE_DIRECTORY:
return yaffs_DeleteDirectory(obj);
default:
return YAFFS_FAIL;
}
+ } else {
+ return yaffs_ChangeObjectName(obj, obj->myDev->unlinkedDir,
+ _Y("unlinked"), 0, 0);
}
}
obj =
yaffs_FindOrCreateObjectByNumber(dev, objId,
YAFFS_OBJECT_TYPE_FILE);
+ if (!obj)
+ return;
yaffs_AddObjectToDirectory(dev->unlinkedDir, obj);
obj->variant.fileVariant.shrinkSize = 0;
obj->valid = 1; /* So that we don't read any other info for this file */
&dev->unlinkedDir->variant.directoryVariant.children) {
if (i) {
l = ylist_entry(i, yaffs_Object, siblings);
- yaffs_DestroyObject(l);
+ yaffs_DeleteObject(l);
}
}
&dev->deletedDir->variant.directoryVariant.children) {
if (i) {
l = ylist_entry(i, yaffs_Object, siblings);
- yaffs_DestroyObject(l);
+ yaffs_DeleteObject(l);
}
}
bi->blockState = state;
bi->sequenceNumber = sequenceNumber;
+ if(bi->sequenceNumber == YAFFS_SEQUENCE_BAD_BLOCK)
+ bi->blockState = state = YAFFS_BLOCK_STATE_DEAD;
+
T(YAFFS_TRACE_SCAN_DEBUG,
(TSTR("Block scanning block %d state %d seq %d" TENDSTR), blk,
state, sequenceNumber));
* deleted, and worse still it has changed type. Delete the old object.
*/
- yaffs_DestroyObject(in);
+ yaffs_DeleteObject(in);
in = 0;
}
yaffs_FindOrCreateObjectByNumber
(dev, oh->parentObjectId,
YAFFS_OBJECT_TYPE_DIRECTORY);
- if (parent->variantType ==
+ if(!parent)
+ alloc_failed = 1;
+ if (parent && parent->variantType ==
YAFFS_OBJECT_TYPE_UNKNOWN) {
/* Set up as a directory */
parent->variantType =
YINIT_LIST_HEAD(&parent->variant.
directoryVariant.
children);
- } else if (parent->variantType !=
+ } else if (!parent || parent->variantType !=
YAFFS_OBJECT_TYPE_DIRECTORY)
{
/* Hoosterman, another problem....
*/
obj = yaffs_FindObjectByNumber(dev,fixer->shadowedId);
if(obj)
- yaffs_DestroyObject(obj);
+ yaffs_DeleteObject(obj);
obj = yaffs_FindObjectByNumber(dev,fixer->objectId);
if(obj){
if(bi->sequenceNumber == YAFFS_SEQUENCE_CHECKPOINT_DATA)
bi->blockState = state = YAFFS_BLOCK_STATE_CHECKPOINT;
+ if(bi->sequenceNumber == YAFFS_SEQUENCE_BAD_BLOCK)
+ bi->blockState = state = YAFFS_BLOCK_STATE_DEAD;
T(YAFFS_TRACE_SCAN_DEBUG,
(TSTR("Block scanning block %d state %d seq %d" TENDSTR), blk,
(TSTR(" Unfixed ECC in chunk(%d:%d), chunk ignored"TENDSTR),
blk, c));
- /* Don't actually delete because the chunk is not yet set up as being in use */
- /* yaffs_DeleteChunk(dev, chunk, 1, __LINE__); */
+ dev->nFreeChunks++;
+
}else if (tags.chunkId > 0) {
/* chunkId > 0 so it is a data chunk... */
unsigned int endpos;
in = yaffs_FindOrCreateObjectByNumber
(dev, tags.objectId,
tags.extraObjectType);
+ if (!in)
+ alloc_failed = 1;
}
if (!in ||
oh->isShrink = oh->inbandIsShrink;
}
- if (!in)
+ if (!in) {
in = yaffs_FindOrCreateObjectByNumber(dev, tags.objectId, oh->type);
+ if (!in)
+ alloc_failed = 1;
+ }
}
(TSTR
("yaffs tragedy: Could not make object for object %d at chunk %d during scan"
TENDSTR), tags.objectId, chunk));
-
+ continue;
}
if (in->valid) {
}
+ if (!in->valid && in->variantType !=
+ (oh ? oh->type : tags.extraObjectType))
+ T(YAFFS_TRACE_ERROR, (
+ TSTR("yaffs tragedy: Bad object type, "
+ TCONT("%d != %d, for object %d at chunk ")
+ TCONT("%d during scan")
+ TENDSTR), oh ?
+ oh->type : tags.extraObjectType,
+ in->variantType, tags.objectId,
+ chunk));
+
if (!in->valid &&
(tags.objectId == YAFFS_OBJECTID_ROOT ||
tags.objectId ==
}
in->dirty = 0;
+ if (!parent)
+ alloc_failed = 1;
+
/* directory stuff...
* hook up to parent
*/
- if (parent->variantType ==
+ if (parent && parent->variantType ==
YAFFS_OBJECT_TYPE_UNKNOWN) {
/* Set up as a directory */
parent->variantType =
YINIT_LIST_HEAD(&parent->variant.
directoryVariant.
children);
- } else if (parent->variantType !=
+ } else if (!parent || parent->variantType !=
YAFFS_OBJECT_TYPE_DIRECTORY)
{
/* Hoosterman, another problem....
if(!obj){
T(YAFFS_TRACE_ALWAYS, (TSTR("No object to verify" TENDSTR)));
YBUG();
+ return;
}
if(yaffs_SkipVerification(obj->myDev))
if(!obj->parent){
T(YAFFS_TRACE_ALWAYS, (TSTR("Object does not have parent" TENDSTR)));
YBUG();
+ return;
}
if(obj->parent->variantType != YAFFS_OBJECT_TYPE_DIRECTORY){
struct ylist_head *lh;
yaffs_Object *listObj;
- if(!directory)
+ if(!directory){
YBUG();
+ return;
+ }
if(yaffs_SkipFullVerification(directory->myDev))
return;
("tragedy: Trying to add an object to a null pointer directory"
TENDSTR)));
YBUG();
+ return;
}
if (directory->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) {
T(YAFFS_TRACE_ALWAYS,
/* Not initialised */
YBUG();
- } else if (ylist_empty(&obj->siblings)) {
- YBUG();
}
-
yaffs_VerifyDirectory(directory);
yaffs_RemoveObjectFromDirectory(obj);
("tragedy: yaffs_FindObjectByName: null pointer directory"
TENDSTR)));
YBUG();
+ return NULL;
}
if (directory->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) {
T(YAFFS_TRACE_ALWAYS,
("tragedy: yaffs_FindObjectByName: null pointer directory"
TENDSTR)));
YBUG();
+ return YAFFS_FAIL;
}
if (theDir->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) {
T(YAFFS_TRACE_ALWAYS,
(TSTR
("tragedy: yaffs_FindObjectByName: non-directory" TENDSTR)));
YBUG();
+ return YAFFS_FAIL;
}
ylist_for_each(i, &theDir->variant.directoryVariant.children) {