YBUG();
}
-/* Function to return the number of shifts for a power of 2 greater than or equal
+/* Function to return the number of shifts for a power of 2 greater than or equal
* to the given number
* Note we don't try to cater for all possible numbers and this does not have to
* be hellishly efficient.
*/
-
+
static __u32 ShiftsGE(__u32 x)
{
int extraBits;
int nShifts;
-
+
nShifts = extraBits = 0;
-
+
while(x>1){
if(x & 1) extraBits++;
x>>=1;
nShifts++;
}
- if(extraBits)
+ if(extraBits)
nShifts++;
-
+
return nShifts;
}
/* Function to return the number of shifts to get a 1 in bit 0
*/
-
+
static __u32 ShiftDiv(__u32 x)
{
int nShifts;
-
+
nShifts = 0;
-
+
if(!x) return 0;
-
+
while( !(x&1)){
x>>=1;
nShifts++;
}
-
+
return nShifts;
}
-/*
+/*
* Temporary buffer manipulations.
*/
-static int yaffs_InitialiseTempBuffers(yaffs_Device *dev)
+static int yaffs_InitialiseTempBuffers(yaffs_Device *dev)
{
int i;
__u8 *buf = (__u8 *)1;
-
+
memset(dev->tempBuffer,0,sizeof(dev->tempBuffer));
-
+
for (i = 0; buf && i < YAFFS_N_TEMP_BUFFERS; i++) {
dev->tempBuffer[i].line = 0; /* not in use */
dev->tempBuffer[i].buffer = buf =
YMALLOC_DMA(dev->nDataBytesPerChunk);
}
-
+
return buf ? YAFFS_OK : YAFFS_FAIL;
-
+
}
static __u8 *yaffs_GetTempBuffer(yaffs_Device * dev, int lineNo)
static Y_INLINE void yaffs_SetChunkBit(yaffs_Device * dev, int blk, int chunk)
{
__u8 *blkBits = yaffs_BlockBits(dev, blk);
-
+
yaffs_VerifyChunkBitId(dev,blk,chunk);
blkBits[chunk / 8] |= (1 << (chunk & 7));
n++;
x >>=1;
}
-
+
blkBits++;
}
return n;
}
-/*
+/*
* Verification code
*/
-
+
static int yaffs_SkipVerification(yaffs_Device *dev)
{
return !(yaffs_traceMask & (YAFFS_TRACE_VERIFY | YAFFS_TRACE_VERIFY_FULL));
{
int actuallyUsed;
int inUse;
-
+
if(yaffs_SkipVerification(dev))
return;
-
+
/* Report illegal runtime states */
if(bi->blockState <0 || bi->blockState >= YAFFS_NUMBER_OF_BLOCK_STATES)
T(YAFFS_TRACE_VERIFY,(TSTR("Block %d has undefined state %d"TENDSTR),n,bi->blockState));
-
+
switch(bi->blockState){
case YAFFS_BLOCK_STATE_UNKNOWN:
case YAFFS_BLOCK_STATE_SCANNING:
T(YAFFS_TRACE_VERIFY,(TSTR("Block %d has bad run-state %s"TENDSTR),
n,blockStateName[bi->blockState]));
}
-
+
/* Check pages in use and soft deletions are legal */
-
+
actuallyUsed = bi->pagesInUse - bi->softDeletions;
-
+
if(bi->pagesInUse < 0 || bi->pagesInUse > dev->nChunksPerBlock ||
bi->softDeletions < 0 || bi->softDeletions > dev->nChunksPerBlock ||
actuallyUsed < 0 || actuallyUsed > dev->nChunksPerBlock)
T(YAFFS_TRACE_VERIFY,(TSTR("Block %d has illegal values pagesInUsed %d softDeletions %d"TENDSTR),
n,bi->pagesInUse,bi->softDeletions));
-
-
+
+
/* Check chunk bitmap legal */
inUse = yaffs_CountChunkBits(dev,n);
if(inUse != bi->pagesInUse)
T(YAFFS_TRACE_VERIFY,(TSTR("Block %d has inconsistent values pagesInUse %d counted chunk bits %d"TENDSTR),
n,bi->pagesInUse,inUse));
-
+
/* Check that the sequence number is valid.
- * Ten million is legal, but is very unlikely
+ * Ten million is legal, but is very unlikely
*/
- if(dev->isYaffs2 &&
+ if(dev->isYaffs2 &&
(bi->blockState == YAFFS_BLOCK_STATE_ALLOCATING || bi->blockState == YAFFS_BLOCK_STATE_FULL) &&
(bi->sequenceNumber < YAFFS_LOWEST_SEQUENCE_NUMBER || bi->sequenceNumber > 10000000 ))
T(YAFFS_TRACE_VERIFY,(TSTR("Block %d has suspect sequence number of %d"TENDSTR),
n,bi->sequenceNumber));
-
+
}
static void yaffs_VerifyCollectedBlock(yaffs_Device *dev,yaffs_BlockInfo *bi,int n)
{
yaffs_VerifyBlock(dev,bi,n);
-
+
/* After collection the block should be in the erased state */
/* TODO: This will need to change if we do partial gc */
-
+
if(bi->blockState != YAFFS_BLOCK_STATE_EMPTY){
T(YAFFS_TRACE_ERROR,(TSTR("Block %d is in state %d after gc, should be erased"TENDSTR),
n,bi->blockState));
int i;
int nBlocksPerState[YAFFS_NUMBER_OF_BLOCK_STATES];
int nIllegalBlockStates = 0;
-
+
if(yaffs_SkipVerification(dev))
return;
memset(nBlocksPerState,0,sizeof(nBlocksPerState));
-
+
for(i = dev->internalStartBlock; i <= dev->internalEndBlock; i++){
yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev,i);
yaffs_VerifyBlock(dev,bi,i);
nBlocksPerState[bi->blockState]++;
else
nIllegalBlockStates++;
-
+
}
-
+
T(YAFFS_TRACE_VERIFY,(TSTR(""TENDSTR)));
T(YAFFS_TRACE_VERIFY,(TSTR("Block summary"TENDSTR)));
-
+
T(YAFFS_TRACE_VERIFY,(TSTR("%d blocks have illegal states"TENDSTR),nIllegalBlockStates));
if(nBlocksPerState[YAFFS_BLOCK_STATE_ALLOCATING] > 1)
T(YAFFS_TRACE_VERIFY,(TSTR("Too many allocating blocks"TENDSTR)));
T(YAFFS_TRACE_VERIFY,
(TSTR("%s %d blocks"TENDSTR),
blockStateName[i],nBlocksPerState[i]));
-
+
if(dev->blocksInCheckpoint != nBlocksPerState[YAFFS_BLOCK_STATE_CHECKPOINT])
T(YAFFS_TRACE_VERIFY,
(TSTR("Checkpoint block count wrong dev %d count %d"TENDSTR),
dev->blocksInCheckpoint, nBlocksPerState[YAFFS_BLOCK_STATE_CHECKPOINT]));
-
+
if(dev->nErasedBlocks != nBlocksPerState[YAFFS_BLOCK_STATE_EMPTY])
T(YAFFS_TRACE_VERIFY,
(TSTR("Erased block count wrong dev %d count %d"TENDSTR),
dev->nErasedBlocks, nBlocksPerState[YAFFS_BLOCK_STATE_EMPTY]));
-
+
if(nBlocksPerState[YAFFS_BLOCK_STATE_COLLECTING] > 1)
T(YAFFS_TRACE_VERIFY,
(TSTR("Too many collecting blocks %d (max is 1)"TENDSTR),
{
if(yaffs_SkipVerification(obj->myDev))
return;
-
+
if(!(tags && obj && oh)){
T(YAFFS_TRACE_VERIFY,
(TSTR("Verifying object header tags %x obj %x oh %x"TENDSTR),
(__u32)tags,(__u32)obj,(__u32)oh));
return;
}
-
+
if(oh->type <= YAFFS_OBJECT_TYPE_UNKNOWN ||
oh->type > YAFFS_OBJECT_TYPE_MAX)
T(YAFFS_TRACE_VERIFY,
/*
* Check that the object's parent ids match if parentCheck requested.
- *
+ *
* Tests do not apply to the root object.
*/
-
+
if(parentCheck && tags->objectId > 1 && !obj->parent)
T(YAFFS_TRACE_VERIFY,
(TSTR("Obj %d header mismatch parentId %d obj->parent is NULL"TENDSTR),
tags->objectId, oh->parentObjectId));
-
-
+
+
if(parentCheck && obj->parent &&
- oh->parentObjectId != obj->parent->objectId &&
+ oh->parentObjectId != obj->parent->objectId &&
(oh->parentObjectId != YAFFS_OBJECTID_UNLINKED ||
obj->parent->objectId != YAFFS_OBJECTID_DELETED))
T(YAFFS_TRACE_VERIFY,
(TSTR("Obj %d header mismatch parentId %d parentObjectId %d"TENDSTR),
tags->objectId, oh->parentObjectId, obj->parent->objectId));
-
-
+
+
if(tags->objectId > 1 && oh->name[0] == 0) /* Null name */
T(YAFFS_TRACE_VERIFY,
(TSTR("Obj %d header name is NULL"TENDSTR),
int i;
yaffs_ExtendedTags tags;
__u32 objectId = obj->objectId;
-
+
chunkOffset <<= YAFFS_TNODES_LEVEL0_BITS;
-
+
for(i = 0; i < YAFFS_NTNODES_LEVEL0; i++){
__u32 theChunk = yaffs_GetChunkGroupBase(dev,tn,i);
-
+
if(theChunk > 0){
/* T(~0,(TSTR("verifying (%d:%d) %d"TENDSTR),tags.objectId,tags.chunkId,theChunk)); */
yaffs_ReadChunkWithTagsFromNAND(dev,theChunk,NULL, &tags);
yaffs_ExtendedTags tags;
yaffs_Tnode *tn;
__u32 objectId;
-
+
if(obj && yaffs_SkipVerification(obj->myDev))
return;
-
+
dev = obj->myDev;
objectId = obj->objectId;
-
+
/* Check file size is consistent with tnode depth */
lastChunk = obj->variant.fileVariant.fileSize / dev->nDataBytesPerChunk + 1;
x = lastChunk >> YAFFS_TNODES_LEVEL0_BITS;
x >>= YAFFS_TNODES_INTERNAL_BITS;
requiredTallness++;
}
-
+
actualTallness = obj->variant.fileVariant.topLevel;
-
+
if(requiredTallness > actualTallness )
T(YAFFS_TRACE_VERIFY,
(TSTR("Obj %d had tnode tallness %d, needs to be %d"TENDSTR),
obj->objectId,actualTallness, requiredTallness));
-
-
- /* Check that the chunks in the tnode tree are all correct.
+
+
+ /* Check that the chunks in the tnode tree are all correct.
* We do this by scanning through the tnode tree and
* checking the tags for every chunk match.
*/
if(yaffs_SkipNANDVerification(dev))
return;
-
+
for(i = 1; i <= lastChunk; i++){
tn = yaffs_FindLevel0Tnode(dev, &obj->variant.fileVariant,i);
{
if(obj && yaffs_SkipVerification(obj->myDev))
return;
-
+
}
static void yaffs_VerifyHardLink(yaffs_Object *obj)
{
if(obj && yaffs_SkipVerification(obj->myDev))
return;
-
+
/* Verify sane equivalent object */
}
{
if(obj && yaffs_SkipVerification(obj->myDev))
return;
-
+
/* Verify symlink string */
}
static void yaffs_VerifyObject(yaffs_Object *obj)
{
yaffs_Device *dev;
-
+
__u32 chunkMin;
__u32 chunkMax;
-
+
__u32 chunkIdOk;
__u32 chunkIsLive;
-
+
if(!obj)
return;
-
+
dev = obj->myDev;
-
+
if(yaffs_SkipVerification(dev))
return;
-
+
/* Check sane object header chunk */
-
+
chunkMin = dev->internalStartBlock * dev->nChunksPerBlock;
chunkMax = (dev->internalEndBlock+1) * dev->nChunksPerBlock - 1;
-
+
chunkIdOk = (obj->chunkId >= chunkMin && obj->chunkId <= chunkMax);
- chunkIsLive = chunkIdOk &&
- yaffs_CheckChunkBit(dev,
+ chunkIsLive = chunkIdOk &&
+ yaffs_CheckChunkBit(dev,
obj->chunkId / dev->nChunksPerBlock,
obj->chunkId % dev->nChunksPerBlock);
- if(!obj->fake &&
+ if(!obj->fake &&
(!chunkIdOk || !chunkIsLive)) {
T(YAFFS_TRACE_VERIFY,
(TSTR("Obj %d has chunkId %d %s %s"TENDSTR),
chunkIdOk ? "" : ",out of range",
chunkIsLive || !chunkIdOk ? "" : ",marked as deleted"));
}
-
+
if(chunkIdOk && chunkIsLive &&!yaffs_SkipNANDVerification(dev)) {
yaffs_ExtendedTags tags;
yaffs_ObjectHeader *oh;
__u8 *buffer = yaffs_GetTempBuffer(dev,__LINE__);
-
+
oh = (yaffs_ObjectHeader *)buffer;
-
+
yaffs_ReadChunkWithTagsFromNAND(dev, obj->chunkId,buffer, &tags);
-
+
yaffs_VerifyObjectHeader(obj,oh,&tags,1);
-
+
yaffs_ReleaseTempBuffer(dev,buffer,__LINE__);
}
-
+
/* Verify it has a parent */
if(obj && !obj->fake &&
(!obj->parent || obj->parent->myDev != dev)){
T(YAFFS_TRACE_VERIFY,
(TSTR("Obj %d has parent pointer %p which does not look like an object"TENDSTR),
- obj->objectId,obj->parent));
+ obj->objectId,obj->parent));
}
-
+
/* Verify parent is a directory */
if(obj->parent && obj->parent->variantType != YAFFS_OBJECT_TYPE_DIRECTORY){
T(YAFFS_TRACE_VERIFY,
(TSTR("Obj %d's parent is not a directory (type %d)"TENDSTR),
- obj->objectId,obj->parent->variantType));
+ obj->objectId,obj->parent->variantType));
}
-
+
switch(obj->variantType){
case YAFFS_OBJECT_TYPE_FILE:
yaffs_VerifyFile(obj);
default:
T(YAFFS_TRACE_VERIFY,
(TSTR("Obj %d has illegaltype %d"TENDSTR),
- obj->objectId,obj->variantType));
+ obj->objectId,obj->variantType));
break;
}
-
-
+
+
}
static void yaffs_VerifyObjects(yaffs_Device *dev)
if(yaffs_SkipVerification(dev))
return;
-
+
/* Iterate through the objects in each hash entry */
-
+
for(i = 0; i < YAFFS_NOBJECT_BUCKETS; i++){
list_for_each(lh, &dev->objectBucket[i].list) {
if (lh) {
/*
* Simple hash function. Needs to have a reasonable spread
*/
-
+
static Y_INLINE int yaffs_HashFunction(int n)
{
n = abs(n);
/*
* Access functions to useful fake objects
*/
-
+
yaffs_Object *yaffs_Root(yaffs_Device * dev)
{
return dev->rootDir;
/*
* Erased NAND checking functions
*/
-
+
int yaffs_CheckFF(__u8 * buffer, int nBytes)
{
/* Horrible, slow implementation */
int result;
result = yaffs_ReadChunkWithTagsFromNAND(dev, chunkInNAND, data, &tags);
-
+
if(tags.eccResult > YAFFS_ECC_RESULT_NO_ERROR)
retval = YAFFS_FAIL;
-
+
if (!yaffs_CheckFF(data, dev->nDataBytesPerChunk) || tags.chunkUsed) {
T(YAFFS_TRACE_NANDACCESS,
/*
* Block retiring for handling a broken block.
*/
-
+
static void yaffs_RetireBlock(yaffs_Device * dev, int blockInNAND)
{
yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, blockInNAND);
yaffs_InvalidateCheckpoint(dev);
-
+
yaffs_MarkBlockBad(dev, blockInNAND);
bi->blockState = YAFFS_BLOCK_STATE_DEAD;
* Functions for robustisizing TODO
*
*/
-
+
static void yaffs_HandleWriteChunkOk(yaffs_Device * dev, int chunkInNAND,
const __u8 * data,
const yaffs_ExtendedTags * tags)
bi->gcPrioritise = 1;
dev->hasPendingPrioritisedGCs = 1;
bi->chunkErrorStrikes ++;
-
+
if(bi->chunkErrorStrikes > 3){
bi->needsRetiring = 1; /* Too many stikes, so retire this */
T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: Block struck out" TENDSTR)));
}
-
+
}
}
yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, blockInNAND);
yaffs_HandleChunkError(dev,bi);
-
-
+
+
if(erasedOk ) {
/* Was an actual write failure, so mark the block for retirement */
bi->needsRetiring = 1;
T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS,
(TSTR("**>> Block %d needs retiring" TENDSTR), blockInNAND));
-
+
}
-
+
/* Delete the chunk */
yaffs_DeleteChunk(dev, chunkInNAND, 1, __LINE__);
}
-/*---------------- Name handling functions ------------*/
+/*---------------- Name handling functions ------------*/
static __u16 yaffs_CalcNameSum(const YCHAR * name)
{
* The list is hooked together using the first pointer
* in the tnode.
*/
-
+
/* yaffs_CreateTnodes creates a bunch more tnodes and
* adds them to the tnode free list.
* Don't use this function directly
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;
next = (yaffs_Tnode *) &mem[(i+1) * tnodeSize];
curr->internal[0] = next;
}
-
+
curr = (yaffs_Tnode *) &mem[(nTnodes - 1) * tnodeSize];
curr->internal[0] = dev->freeTnodes;
dev->freeTnodes = (yaffs_Tnode *)mem;
* NB If we can't add this to the management list it isn't fatal
* but it just means we can't free this bunch of tnodes later.
*/
-
+
tnl = YMALLOC(sizeof(yaffs_TnodeList));
if (!tnl) {
T(YAFFS_TRACE_ERROR,
static yaffs_Tnode *yaffs_GetTnode(yaffs_Device * dev)
{
yaffs_Tnode *tn = yaffs_GetTnodeRaw(dev);
-
+
if(tn)
memset(tn, 0, (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8);
- return tn;
+ return tn;
}
/* FreeTnode frees up a tnode and puts it back on the free list */
__u32 bitInWord;
__u32 wordInMap;
__u32 mask;
-
+
pos &= YAFFS_TNODES_LEVEL0_MASK;
val >>= dev->chunkGroupBits;
-
+
bitInMap = pos * dev->tnodeWidth;
wordInMap = bitInMap /32;
bitInWord = bitInMap & (32 -1);
-
+
mask = dev->tnodeMask << bitInWord;
-
+
map[wordInMap] &= ~mask;
map[wordInMap] |= (mask & (val << bitInWord));
-
+
if(dev->tnodeWidth > (32-bitInWord)) {
bitInWord = (32 - bitInWord);
wordInMap++;;
__u32 bitInWord;
__u32 wordInMap;
__u32 val;
-
+
pos &= YAFFS_TNODES_LEVEL0_MASK;
-
+
bitInMap = pos * dev->tnodeWidth;
wordInMap = bitInMap /32;
bitInWord = bitInMap & (32 -1);
-
+
val = map[wordInMap] >> bitInWord;
-
+
if(dev->tnodeWidth > (32-bitInWord)) {
bitInWord = (32 - bitInWord);
wordInMap++;;
val |= (map[wordInMap] << bitInWord);
}
-
+
val &= dev->tnodeMask;
val <<= dev->chunkGroupBits;
-
+
return val;
}
while (level > 0 && tn) {
tn = tn->
internal[(chunkId >>
- ( YAFFS_TNODES_LEVEL0_BITS +
+ ( YAFFS_TNODES_LEVEL0_BITS +
(level - 1) *
YAFFS_TNODES_INTERNAL_BITS)
) &
* If the tn argument is NULL, then a fresh tnode will be added otherwise the specified tn will
* be plugged into the ttree.
*/
-
+
static yaffs_Tnode *yaffs_AddOrFindLevel0Tnode(yaffs_Device * dev,
yaffs_FileStructure * fStruct,
__u32 chunkId,
if (requiredTallness > fStruct->topLevel) {
/* Not tall enough,gotta make the tree taller */
for (i = fStruct->topLevel; i < requiredTallness; i++) {
-
+
tn = yaffs_GetTnode(dev);
if (tn) {
l = fStruct->topLevel;
tn = fStruct->top;
-
+
if(l > 0) {
while (l > 0 && tn) {
x = (chunkId >>
if(tn->internal[x])
yaffs_FreeTnode(dev,tn->internal[x]);
tn->internal[x] = passedTn;
-
+
} else if(!tn->internal[x]) {
/* Don't have one, none passed in */
tn->internal[x] = yaffs_GetTnode(dev);
}
}
-
+
tn = tn->internal[x];
l--;
}
/* DeleteWorker scans backwards through the tnode tree and deletes all the
* chunks and tnodes in the file
- * Returns 1 if the tree was deleted.
+ * Returns 1 if the tree was deleted.
* Returns 0 if it stopped early due to hitting the limit and the delete is incomplete.
*/
* of the tnode.
* Thus, essentially this is the same as DeleteWorker except that the chunks are soft deleted.
*/
-
+
static int yaffs_SoftDeleteWorker(yaffs_Object * in, yaffs_Tnode * tn,
__u32 level, int chunkOffset)
{
theChunk = yaffs_GetChunkGroupBase(dev,tn,i);
if (theChunk) {
/* Note this does not find the real chunk, only the chunk group.
- * We make an assumption that a chunk group is not larger than
+ * We make an assumption that a chunk group is not larger than
* a block.
*/
yaffs_SoftDeleteChunk(dev, theChunk);
/* Now we have a tree with all the non-zero branches NULL but the height
* is the same as it was.
* Let's see if we can trim internal tnodes to shorten the tree.
- * We can do this if only the 0th element in the tnode is in use
+ * We can do this if only the 0th element in the tnode is in use
* (ie all the non-zero are NULL)
*/
(TSTR("yaffs: Could not allocate more objects" TENDSTR)));
return YAFFS_FAIL;
}
-
+
/* Hook them into the free list */
for (i = 0; i < nObjects - 1; i++) {
newObjects[i].siblings.next =
theObject = yaffs_AllocateEmptyObject(dev);
if(!theObject)
return NULL;
-
+
if(type == YAFFS_OBJECT_TYPE_FILE){
tn = yaffs_GetTnode(dev);
if(!tn){
return NULL;
}
}
-
-
+
+
if (theObject) {
theObject->fake = 0;
return theObject;
}
-
+
static YCHAR *yaffs_CloneString(const YCHAR * str)
{
* aliasString only has meaning for a sumlink.
* rdev only has meaning for devices (a subset of special objects)
*/
-
+
static yaffs_Object *yaffs_MknodObject(yaffs_ObjectType type,
yaffs_Object * parent,
const YCHAR * name,
}
in = yaffs_CreateNewObject(dev, -1, type);
-
+
if(type == YAFFS_OBJECT_TYPE_SYMLINK){
str = yaffs_CloneString(aliasString);
if(!str){
return NULL;
}
}
-
-
+
+
if (in) {
in->chunkId = -1;
equivalentObject->objectId;
list_add(&in->hardLinks, &equivalentObject->hardLinks);
break;
- case YAFFS_OBJECT_TYPE_FILE:
+ case YAFFS_OBJECT_TYPE_FILE:
case YAFFS_OBJECT_TYPE_DIRECTORY:
case YAFFS_OBJECT_TYPE_SPECIAL:
case YAFFS_OBJECT_TYPE_UNKNOWN:
TENDSTR)));
YBUG();
}
-
+
/* TODO: Do we need this different handling for YAFFS2 and YAFFS1?? */
if (obj->myDev->isYaffs2) {
unlinkOp = (newDir == obj->myDev->unlinkedDir);
existingTarget = yaffs_FindObjectByName(newDir, newName);
- /* If the object is a file going into the unlinked directory,
+ /* If the object is a file going into the unlinked directory,
* then it is OK to just stuff it in since duplicate names are allowed.
- * else only proceed if the new name does not exist and if we're putting
+ * else only proceed if the new name does not exist and if we're putting
* it into a directory.
*/
if ((unlinkOp ||
/* There is a target that is a non-empty directory, so we fail */
return YAFFS_FAIL; /* EEXIST or ENOTEMPTY */
} else if (existingTarget && existingTarget != obj) {
- /* Nuke the target first, using shadowing,
+ /* Nuke the target first, using shadowing,
* but only if it isn't the same object
*/
yaffs_ChangeObjectName(obj, newDir, newName, force,
static int yaffs_InitialiseBlocks(yaffs_Device * dev)
{
int nBlocks = dev->internalEndBlock - dev->internalStartBlock + 1;
-
+
dev->blockInfo = NULL;
dev->chunkBits = NULL;
-
+
dev->allocationBlock = -1; /* force it to get a new one */
/* If the first allocation strategy fails, thry the alternate one */
}
else
dev->blockInfoAlt = 0;
-
+
if(dev->blockInfo){
-
+
/* Set up dynamic blockinfo stuff. */
dev->chunkBitmapStride = (dev->nChunksPerBlock + 7) / 8; /* round up bytes */
dev->chunkBits = YMALLOC(dev->chunkBitmapStride * nBlocks);
else
dev->chunkBitsAlt = 0;
}
-
+
if (dev->blockInfo && dev->chunkBits) {
memset(dev->blockInfo, 0, nBlocks * sizeof(yaffs_BlockInfo));
memset(dev->chunkBits, 0, dev->chunkBitmapStride * nBlocks);
dev->blockInfoAlt = 0;
dev->blockInfo = NULL;
-
+
if(dev->chunkBitsAlt && dev->chunkBits)
YFREE_ALT(dev->chunkBits);
else if(dev->chunkBits)
int prioritised=0;
yaffs_BlockInfo *bi;
int pendingPrioritisedExist = 0;
-
+
/* First let's see if we need to grab a prioritised block */
if(dev->hasPendingPrioritisedGCs){
for(i = dev->internalStartBlock; i < dev->internalEndBlock && !prioritised; i++){
bi = yaffs_GetBlockInfo(dev, i);
//yaffs_VerifyBlock(dev,bi,i);
-
+
if(bi->gcPrioritise) {
pendingPrioritisedExist = 1;
if(bi->blockState == YAFFS_BLOCK_STATE_FULL &&
}
}
}
-
+
if(!pendingPrioritisedExist) /* None found, so we can clear this */
dev->hasPendingPrioritisedGCs = 0;
}
dirtiest = b;
pagesInUse = 0;
}
- else
+ else
#endif
if (bi->blockState == YAFFS_BLOCK_STATE_FULL &&
/* If the block is still healthy erase it and mark as clean.
* If the block has had a data failure, then retire it.
*/
-
+
T(YAFFS_TRACE_GC | YAFFS_TRACE_ERASE,
(TSTR("yaffs_BlockBecameDirty block %d state %d %s"TENDSTR),
blockNo, bi->blockState, (bi->needsRetiring) ? "needs retiring" : ""));
-
+
bi->blockState = YAFFS_BLOCK_STATE_DIRTY;
if (!bi->needsRetiring) {
}
}
- if (erasedOk &&
+ if (erasedOk &&
((yaffs_traceMask & YAFFS_TRACE_ERASE) || !yaffs_SkipVerification(dev))) {
int i;
for (i = 0; i < dev->nChunksPerBlock; i++) {
return -1;
}
-
+
/* Find an empty block. */
for (i = dev->internalStartBlock; i <= dev->internalEndBlock; i++) {
int reservedChunks;
int reservedBlocks = dev->nReservedBlocks;
int checkpointBlocks;
-
+
checkpointBlocks = dev->nCheckpointReservedBlocks - dev->blocksInCheckpoint;
if(checkpointBlocks < 0)
checkpointBlocks = 0;
-
+
reservedChunks = ((reservedBlocks + checkpointBlocks) * dev->nChunksPerBlock);
-
+
return (dev->nFreeChunks > reservedChunks);
}
if(blockUsedPtr)
*blockUsedPtr = bi;
-
+
return retVal;
}
-
+
T(YAFFS_TRACE_ERROR,
(TSTR("!!!!!!!!! Allocator out !!!!!!!!!!!!!!!!!" TENDSTR)));
yaffs_Object *object;
isCheckpointBlock = (bi->blockState == YAFFS_BLOCK_STATE_CHECKPOINT);
-
+
bi->blockState = YAFFS_BLOCK_STATE_COLLECTING;
T(YAFFS_TRACE_TRACING,
} else {
__u8 *buffer = yaffs_GetTempBuffer(dev, __LINE__);
-
+
yaffs_VerifyBlock(dev,bi,block);
for (chunkInBlock = 0, oldChunk = block * dev->nChunksPerBlock;
("Collecting page %d, %d %d %d " TENDSTR),
chunkInBlock, tags.objectId, tags.chunkId,
tags.byteCount));
-
+
if(object && !yaffs_SkipVerification(dev)){
if(tags.chunkId == 0)
matchingChunk = object->chunkId;
matchingChunk = oldChunk; /* Defeat the test */
else
matchingChunk = yaffs_FindChunkInFile(object,tags.chunkId,NULL);
-
+
if(oldChunk != matchingChunk)
T(YAFFS_TRACE_ERROR,
(TSTR("gc: page in gc mismatch: %d %d %d %d"TENDSTR),
oldChunk,matchingChunk,tags.objectId, tags.chunkId));
-
+
}
if (!object) {
&& tags.chunkId != 0) {
/* Data chunk in a deleted file, throw it away
* It's a soft deleted data chunk,
- * No need to copy this, just forget about it and
+ * No need to copy this, just forget about it and
* fix up the object.
*/
oh->shadowsObject = -1;
tags.extraShadows = 0;
tags.extraIsShrinkHeader = 0;
-
+
yaffs_VerifyObjectHeader(object,oh,&tags,1);
}
}
yaffs_VerifyCollectedBlock(dev,bi,block);
-
+
if (chunksBefore >= (chunksAfter = yaffs_GetErasedChunks(dev))) {
T(YAFFS_TRACE_GC,
(TSTR
int aggressive;
int gcOk = YAFFS_OK;
int maxTries = 0;
-
+
int checkpointBlockAdjust;
if (dev->isDoingGC) {
/* Bail out so we don't get recursive gc */
return YAFFS_OK;
}
-
+
/* This loop should pass the first time.
* We'll only see looping here if the erase of the collected block fails.
*/
do {
maxTries++;
-
+
checkpointBlockAdjust = (dev->nCheckpointReservedBlocks - dev->blocksInCheckpoint);
if(checkpointBlockAdjust < 0)
checkpointBlockAdjust = 0;
static int yaffs_PutChunkIntoFile(yaffs_Object * in, int chunkInInode,
int chunkInNAND, int inScan)
{
- /* NB inScan is zero unless scanning.
- * For forward scanning, inScan is > 0;
+ /* NB inScan is zero unless scanning.
+ * For forward scanning, inScan is > 0;
* for backward scanning inScan is < 0
*/
-
+
yaffs_Tnode *tn;
yaffs_Device *dev = in->myDev;
int existingChunk;
return YAFFS_OK;
}
- tn = yaffs_AddOrFindLevel0Tnode(dev,
+ tn = yaffs_AddOrFindLevel0Tnode(dev,
&in->variant.fileVariant,
chunkInInode,
NULL);
if (inScan != 0) {
/* If we're scanning then we need to test for duplicates
- * NB This does not need to be efficient since it should only ever
+ * NB This does not need to be efficient since it should only ever
* happen when the power fails during a write, then only one
* chunk should ever be affected.
*
}
- /* NB The deleted flags should be false, otherwise the chunks will
+ /* NB The deleted flags should be false, otherwise the chunks will
* not be loaded during a scan
*/
(in->myDev->isYaffs2 ||
existingChunk <= 0 ||
((existingSerial + 1) & 3) == newSerial)) {
- /* Forward scanning.
+ /* Forward scanning.
* Use new
* Delete the old one and drop through to update the tnode
*/
(TSTR("Chunk %d not found zero instead" TENDSTR),
chunkInNAND));
/* get sane (zero) data if you read a hole */
- memset(buffer, 0, in->myDev->nDataBytesPerChunk);
+ memset(buffer, 0, in->myDev->nDataBytesPerChunk);
return 0;
}
if (chunkId <= 0)
return;
-
+
dev->nDeletions++;
block = chunkId / dev->nChunksPerBlock;
YCHAR oldName[YAFFS_MAX_NAME_LENGTH + 1];
yaffs_ObjectHeader *oh = NULL;
-
+
yaffs_strcpy(oldName,"silly old name");
if (!in->fake || force) {
if (prevChunkId >= 0) {
result = yaffs_ReadChunkWithTagsFromNAND(dev, prevChunkId,
buffer, &oldTags);
-
+
yaffs_VerifyObjectHeader(in,oh,&oldTags,0);
-
+
memcpy(oldName, oh->name, sizeof(oh->name));
}
/*------------------------ Short Operations Cache ----------------------------------------
* In many situations where there is no high level buffering (eg WinCE) a lot of
- * reads might be short sequential reads, and a lot of writes may be short
+ * reads might be short sequential reads, and a lot of writes may be short
* sequential writes. eg. scanning/writing a jpeg file.
- * In these cases, a short read/write cache can provide a huge perfomance benefit
+ * In these cases, a short read/write cache can provide a huge perfomance benefit
* with dumb-as-a-rock code.
- * In Linux, the page cache provides read buffering aand the short op cache provides write
+ * In Linux, the page cache provides read buffering aand the short op cache provides write
* buffering.
*
* There are a limited number (~10) of cache chunks per device so that we don't
int i;
yaffs_ChunkCache *cache;
int nCaches = obj->myDev->nShortOpCaches;
-
+
for(i = 0; i < nCaches; i++){
cache = &dev->srCache[i];
if (cache->object == obj &&
cache->dirty)
return 1;
}
-
+
return 0;
}
yaffs_Object *obj;
int nCaches = dev->nShortOpCaches;
int i;
-
+
/* Find a dirty object in the cache and flush it...
* until there are no further dirty objects.
*/
if (dev->srCache[i].object &&
dev->srCache[i].dirty)
obj = dev->srCache[i].object;
-
+
}
if(obj)
yaffs_FlushFilesChunkCache(obj);
-
+
} while(obj);
-
+
}
/* Grab us a cache chunk for use.
- * First look for an empty one.
+ * First look for an empty one.
* Then look for the least recently used non-dirty one.
* Then look for the least recently used dirty one...., flush and look again.
*/
if (dev->nShortOpCaches > 0) {
for (i = 0; i < dev->nShortOpCaches; i++) {
- if (!dev->srCache[i].object)
+ if (!dev->srCache[i].object)
return &dev->srCache[i];
}
static int yaffs_WriteCheckpointValidityMarker(yaffs_Device *dev,int head)
{
yaffs_CheckpointValidity cp;
-
+
memset(&cp,0,sizeof(cp));
-
+
cp.structType = sizeof(cp);
cp.magic = YAFFS_MAGIC;
cp.version = YAFFS_CHECKPOINT_VERSION;
cp.head = (head) ? 1 : 0;
-
+
return (yaffs_CheckpointWrite(dev,&cp,sizeof(cp)) == sizeof(cp))?
1 : 0;
}
{
yaffs_CheckpointValidity cp;
int ok;
-
+
ok = (yaffs_CheckpointRead(dev,&cp,sizeof(cp)) == sizeof(cp));
-
+
if(ok)
ok = (cp.structType == sizeof(cp)) &&
(cp.magic == YAFFS_MAGIC) &&
return ok ? 1 : 0;
}
-static void yaffs_DeviceToCheckpointDevice(yaffs_CheckpointDevice *cp,
+static void yaffs_DeviceToCheckpointDevice(yaffs_CheckpointDevice *cp,
yaffs_Device *dev)
{
cp->nErasedBlocks = dev->nErasedBlocks;
cp->allocationBlock = dev->allocationBlock;
cp->allocationPage = dev->allocationPage;
cp->nFreeChunks = dev->nFreeChunks;
-
+
cp->nDeletedFiles = dev->nDeletedFiles;
cp->nUnlinkedFiles = dev->nUnlinkedFiles;
cp->nBackgroundDeletions = dev->nBackgroundDeletions;
cp->sequenceNumber = dev->sequenceNumber;
cp->oldestDirtySequence = dev->oldestDirtySequence;
-
+
}
static void yaffs_CheckpointDeviceToDevice(yaffs_Device *dev,
dev->allocationBlock = cp->allocationBlock;
dev->allocationPage = cp->allocationPage;
dev->nFreeChunks = cp->nFreeChunks;
-
+
dev->nDeletedFiles = cp->nDeletedFiles;
dev->nUnlinkedFiles = cp->nUnlinkedFiles;
dev->nBackgroundDeletions = cp->nBackgroundDeletions;
__u32 nBlocks = (dev->internalEndBlock - dev->internalStartBlock + 1);
int ok;
-
+
/* Write device runtime values*/
yaffs_DeviceToCheckpointDevice(&cp,dev);
cp.structType = sizeof(cp);
-
+
ok = (yaffs_CheckpointWrite(dev,&cp,sizeof(cp)) == sizeof(cp));
-
+
/* Write block info */
if(ok) {
nBytes = nBlocks * sizeof(yaffs_BlockInfo);
ok = (yaffs_CheckpointWrite(dev,dev->blockInfo,nBytes) == nBytes);
}
-
- /* Write chunk bits */
+
+ /* Write chunk bits */
if(ok) {
nBytes = nBlocks * dev->chunkBitmapStride;
ok = (yaffs_CheckpointWrite(dev,dev->chunkBits,nBytes) == nBytes);
__u32 nBytes;
__u32 nBlocks = (dev->internalEndBlock - dev->internalStartBlock + 1);
- int ok;
-
+ int ok;
+
ok = (yaffs_CheckpointRead(dev,&cp,sizeof(cp)) == sizeof(cp));
if(!ok)
return 0;
-
+
if(cp.structType != sizeof(cp))
return 0;
-
-
+
+
yaffs_CheckpointDeviceToDevice(dev,&cp);
-
+
nBytes = nBlocks * sizeof(yaffs_BlockInfo);
-
+
ok = (yaffs_CheckpointRead(dev,dev->blockInfo,nBytes) == nBytes);
-
+
if(!ok)
return 0;
nBytes = nBlocks * dev->chunkBitmapStride;
-
+
ok = (yaffs_CheckpointRead(dev,dev->chunkBits,nBytes) == nBytes);
-
+
return ok ? 1 : 0;
}
cp->objectId = obj->objectId;
cp->parentId = (obj->parent) ? obj->parent->objectId : 0;
cp->chunkId = obj->chunkId;
- cp->variantType = obj->variantType;
+ cp->variantType = obj->variantType;
cp->deleted = obj->deleted;
cp->softDeleted = obj->softDeleted;
cp->unlinked = obj->unlinked;
cp->unlinkAllowed = obj->unlinkAllowed;
cp->serial = obj->serial;
cp->nDataChunks = obj->nDataChunks;
-
+
if(obj->variantType == YAFFS_OBJECT_TYPE_FILE)
cp->fileSizeOrEquivalentObjectId = obj->variant.fileVariant.fileSize;
else if(obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK)
{
yaffs_Object *parent;
-
+
obj->objectId = cp->objectId;
-
+
if(cp->parentId)
parent = yaffs_FindOrCreateObjectByNumber(
obj->myDev,
YAFFS_OBJECT_TYPE_DIRECTORY);
else
parent = NULL;
-
+
if(parent)
yaffs_AddObjectToDirectory(parent, obj);
-
+
obj->chunkId = cp->chunkId;
- obj->variantType = cp->variantType;
+ obj->variantType = cp->variantType;
obj->deleted = cp->deleted;
obj->softDeleted = cp->softDeleted;
obj->unlinked = cp->unlinked;
obj->unlinkAllowed = cp->unlinkAllowed;
obj->serial = cp->serial;
obj->nDataChunks = cp->nDataChunks;
-
+
if(obj->variantType == YAFFS_OBJECT_TYPE_FILE)
obj->variant.fileVariant.fileSize = cp->fileSizeOrEquivalentObjectId;
else if(obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK)
obj->variant.hardLinkVariant.equivalentObjectId = cp->fileSizeOrEquivalentObjectId;
-
+
if(obj->objectId >= YAFFS_NOBJECT_BUCKETS)
obj->lazyLoaded = 1;
}
{
__u32 endMarker = ~0;
int ok = 1;
-
+
if(obj->variantType == YAFFS_OBJECT_TYPE_FILE){
ok = yaffs_CheckpointTnodeWorker(obj,
obj->variant.fileVariant.top,
obj->variant.fileVariant.topLevel,
0);
if(ok)
- ok = (yaffs_CheckpointWrite(obj->myDev,&endMarker,sizeof(endMarker)) ==
+ ok = (yaffs_CheckpointWrite(obj->myDev,&endMarker,sizeof(endMarker)) ==
sizeof(endMarker));
}
-
+
return ok ? 1 : 0;
}
yaffs_FileStructure *fileStructPtr = &obj->variant.fileVariant;
yaffs_Tnode *tn;
int nread = 0;
-
+
ok = (yaffs_CheckpointRead(dev,&baseChunk,sizeof(baseChunk)) == sizeof(baseChunk));
-
+
while(ok && (~baseChunk)){
nread++;
/* Read level 0 tnode */
-
-
+
+
/* printf("read tnode at %d\n",baseChunk); */
tn = yaffs_GetTnodeRaw(dev);
if(tn)
(dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8);
else
ok = 0;
-
+
if(tn && ok){
ok = yaffs_AddOrFindLevel0Tnode(dev,
fileStructPtr,
baseChunk,
tn) ? 1 : 0;
-
+
}
-
+
if(ok)
ok = (yaffs_CheckpointRead(dev,&baseChunk,sizeof(baseChunk)) == sizeof(baseChunk));
-
+
}
T(YAFFS_TRACE_CHECKPOINT,(
TSTR("Checkpoint read tnodes %d records, last %d. ok %d" TENDSTR),
nread,baseChunk,ok));
- return ok ? 1 : 0;
+ return ok ? 1 : 0;
}
-
+
static int yaffs_WriteCheckpointObjects(yaffs_Device *dev)
{
int ok = 1;
struct list_head *lh;
-
+
/* Iterate through the objects in each hash entry,
* dumping them to the checkpointing stream.
*/
-
+
for(i = 0; ok && i < YAFFS_NOBJECT_BUCKETS; i++){
list_for_each(lh, &dev->objectBucket[i].list) {
if (lh) {
T(YAFFS_TRACE_CHECKPOINT,(
TSTR("Checkpoint write object %d parent %d type %d chunk %d obj addr %x" TENDSTR),
cp.objectId,cp.parentId,cp.variantType,cp.chunkId,(unsigned) obj));
-
+
ok = (yaffs_CheckpointWrite(dev,&cp,sizeof(cp)) == sizeof(cp));
-
+
if(ok && obj->variantType == YAFFS_OBJECT_TYPE_FILE){
ok = yaffs_WriteCheckpointTnodes(obj);
}
}
}
}
-
+
/* Dump end of list */
memset(&cp,0xFF,sizeof(yaffs_CheckpointObject));
cp.structType = sizeof(cp);
-
+
if(ok)
ok = (yaffs_CheckpointWrite(dev,&cp,sizeof(cp)) == sizeof(cp));
-
+
return ok ? 1 : 0;
}
int ok = 1;
int done = 0;
yaffs_Object *hardList = NULL;
-
+
while(ok && !done) {
ok = (yaffs_CheckpointRead(dev,&cp,sizeof(cp)) == sizeof(cp));
if(cp.structType != sizeof(cp)) {
cp.structType,sizeof(cp),ok));
ok = 0;
}
-
+
T(YAFFS_TRACE_CHECKPOINT,(TSTR("Checkpoint read object %d parent %d type %d chunk %d " TENDSTR),
cp.objectId,cp.parentId,cp.variantType,cp.chunkId));
-
+
if(ok && cp.objectId == ~0)
done = 1;
else if(ok){
hardList;
hardList = obj;
}
-
+
}
}
}
-
+
if(ok)
yaffs_HardlinkFixup(dev,hardList);
-
+
return ok ? 1 : 0;
}
{
__u32 checkpointSum;
int ok;
-
+
yaffs_GetCheckpointSum(dev,&checkpointSum);
-
+
ok = (yaffs_CheckpointWrite(dev,&checkpointSum,sizeof(checkpointSum)) == sizeof(checkpointSum));
-
+
if(!ok)
return 0;
-
+
return 1;
}
__u32 checkpointSum0;
__u32 checkpointSum1;
int ok;
-
+
yaffs_GetCheckpointSum(dev,&checkpointSum0);
-
+
ok = (yaffs_CheckpointRead(dev,&checkpointSum1,sizeof(checkpointSum1)) == sizeof(checkpointSum1));
-
+
if(!ok)
return 0;
-
+
if(checkpointSum0 != checkpointSum1)
return 0;
-
+
return 1;
}
{
int ok = 1;
-
+
if(dev->skipCheckpointWrite || !dev->isYaffs2){
T(YAFFS_TRACE_CHECKPOINT,(TSTR("skipping checkpoint write" TENDSTR)));
ok = 0;
}
-
+
if(ok)
ok = yaffs_CheckpointOpen(dev,1);
-
+
if(ok){
T(YAFFS_TRACE_CHECKPOINT,(TSTR("write checkpoint validity" TENDSTR)));
ok = yaffs_WriteCheckpointValidityMarker(dev,1);
T(YAFFS_TRACE_CHECKPOINT,(TSTR("write checkpoint validity" TENDSTR)));
ok = yaffs_WriteCheckpointValidityMarker(dev,0);
}
-
+
if(ok){
ok = yaffs_WriteCheckpointSum(dev);
}
-
-
+
+
if(!yaffs_CheckpointClose(dev))
ok = 0;
-
+
if(ok)
dev->isCheckpointed = 1;
- else
+ else
dev->isCheckpointed = 0;
return dev->isCheckpointed;
static int yaffs_ReadCheckpointData(yaffs_Device *dev)
{
int ok = 1;
-
+
if(dev->skipCheckpointRead || !dev->isYaffs2){
T(YAFFS_TRACE_CHECKPOINT,(TSTR("skipping checkpoint read" TENDSTR)));
ok = 0;
}
-
+
if(ok)
ok = yaffs_CheckpointOpen(dev,0); /* open for read */
-
+
if(ok){
- T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint validity" TENDSTR)));
+ T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint validity" TENDSTR)));
ok = yaffs_ReadCheckpointValidityMarker(dev,1);
}
if(ok){
ok = yaffs_ReadCheckpointDevice(dev);
}
if(ok){
- T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint objects" TENDSTR)));
+ T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint objects" TENDSTR)));
ok = yaffs_ReadCheckpointObjects(dev);
}
if(ok){
T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint validity" TENDSTR)));
ok = yaffs_ReadCheckpointValidityMarker(dev,0);
}
-
+
if(ok){
ok = yaffs_ReadCheckpointSum(dev);
T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint checksum %d" TENDSTR),ok));
if(ok)
dev->isCheckpointed = 1;
- else
+ else
dev->isCheckpointed = 0;
return ok ? 1 : 0;
static void yaffs_InvalidateCheckpoint(yaffs_Device *dev)
{
- if(dev->isCheckpointed ||
+ if(dev->isCheckpointed ||
dev->blocksInCheckpoint > 0){
dev->isCheckpointed = 0;
yaffs_CheckpointInvalidateStream(dev);
yaffs_InvalidateCheckpoint(dev);
yaffs_WriteCheckpointData(dev);
}
-
+
T(YAFFS_TRACE_ALWAYS,(TSTR("save exit: isCheckpointed %d"TENDSTR),dev->isCheckpointed));
return dev->isCheckpointed;
{
int retval;
T(YAFFS_TRACE_CHECKPOINT,(TSTR("restore entry: isCheckpointed %d"TENDSTR),dev->isCheckpointed));
-
+
retval = yaffs_ReadCheckpointData(dev);
if(dev->isCheckpointed){
}
T(YAFFS_TRACE_CHECKPOINT,(TSTR("restore exit: isCheckpointed %d"TENDSTR),dev->isCheckpointed));
-
+
return retval;
}
chunk++;
/* OK now check for the curveball where the start and end are in
- * the same chunk.
+ * the same chunk.
*/
if ((start + n) < dev->nDataBytesPerChunk) {
nToCopy = n;
yaffs_ChunkCache *cache;
/* If we can't find the data in the cache, then load the cache */
cache = yaffs_FindChunkCache(in, chunk);
-
+
if (!cache
&& yaffs_CheckSpaceForAllocation(in->
myDev)) {
cache->
data);
}
- else if(cache &&
+ else if(cache &&
!cache->dirty &&
!yaffs_CheckSpaceForAllocation(in->myDev)){
/* Drop the cache if it was a read cache item and
* no space check has been made for it.
- */
+ */
cache = NULL;
}
int oldFileSize = in->variant.fileVariant.fileSize;
int newSizeOfPartialChunk;
int newFullChunks;
-
+
yaffs_Device *dev = in->myDev;
yaffs_AddrToChunk(dev, newSize, &newFullChunks, &newSizeOfPartialChunk);
if (newSizeOfPartialChunk != 0) {
int lastChunk = 1 + newFullChunks;
-
+
__u8 *localBuffer = yaffs_GetTempBuffer(dev, __LINE__);
/* Got to read and rewrite the last chunk with its new size and zero pad */
in->variant.fileVariant.fileSize = newSize;
}
-
-
+
+
/* Write a new object header.
* show we've shrunk the file, if need be
* Do this only if the file is not in the deleted directories.
{
yaffs_Object *hl;
yaffs_Object *in;
-
+
while (hardList) {
hl = hardList;
hardList = (yaffs_Object *) (hardList->hardLinks.next);
yaffs_Object *in;
yaffs_Object *parent;
int nBlocks = dev->internalEndBlock - dev->internalStartBlock + 1;
-
+
int alloc_failed = 0;
-
+
__u8 *chunkData;
(TSTR("yaffs_Scan is not for YAFFS2!" TENDSTR)));
return YAFFS_FAIL;
}
-
+
//TODO Throw all the yaffs2 stuuf out of yaffs_Scan since it is only for yaffs1 format.
-
+
T(YAFFS_TRACE_SCAN,
(TSTR("yaffs_Scan starts intstartblk %d intendblk %d..." TENDSTR),
dev->internalStartBlock, dev->internalEndBlock));
/*T((" %d %d deleted\n",blk,c)); */
} else if (!tags.chunkUsed) {
/* An unassigned chunk in the block
- * This means that either the block is empty or
+ * This means that either the block is empty or
* this is the one being allocated from
*/
state = YAFFS_BLOCK_STATE_ALLOCATING;
dev->allocationBlock = blk;
dev->allocationPage = c;
- dev->allocationBlockFinder = blk;
+ dev->allocationBlockFinder = blk;
/* Set it to here to encourage the allocator to go forth from here. */
-
+
/* Yaffs2 sanity check:
* This should be the one with the highest sequence number
*/
/* PutChunkIntoFile checks for a clash (two data chunks with
* the same chunkId).
*/
-
+
if(!in)
alloc_failed = 1;
if(!yaffs_PutChunkIntoFile(in, tags.chunkId, chunk,1))
alloc_failed = 1;
}
-
+
endpos =
(tags.chunkId - 1) * dev->nDataBytesPerChunk +
tags.byteCount;
- if (in &&
+ if (in &&
in->variantType == YAFFS_OBJECT_TYPE_FILE
&& in->variant.fileVariant.scannedFileSize <
endpos) {
tags.objectId);
if (in && in->variantType != oh->type) {
/* This should not happen, but somehow
- * Wev'e ended up with an objectId that has been reused but not yet
+ * Wev'e ended up with an objectId that has been reused but not yet
* deleted, and worse still it has changed type. Delete the old object.
*/
if(!in)
alloc_failed = 1;
-
+
if (in && oh->shadowsObject > 0) {
yaffs_HandleShadowedObject(dev,
oh->
* Since we might scan a hardlink before its equivalent object is scanned
* we put them all in a list.
* After scanning is complete, we should have all the objects, so we run through this
- * list and fix up all the chains.
+ * list and fix up all the chains.
*/
switch (in->variantType) {
- case YAFFS_OBJECT_TYPE_UNKNOWN:
+ case YAFFS_OBJECT_TYPE_UNKNOWN:
/* Todo got a problem */
break;
case YAFFS_OBJECT_TYPE_FILE:
case YAFFS_OBJECT_TYPE_SPECIAL:
/* Do nothing */
break;
- case YAFFS_OBJECT_TYPE_SYMLINK:
+ case YAFFS_OBJECT_TYPE_SYMLINK:
in->variant.symLinkVariant.alias =
yaffs_CloneString(oh->alias);
if(!in->variant.symLinkVariant.alias)
if (blockIndex) {
YFREE(blockIndex);
}
-
-
+
+
/* Ok, we've done all the scanning.
* Fix up the hard link chains.
- * We should now have scanned all the objects, now it's time to add these
+ * We should now have scanned all the objects, now it's time to add these
* hardlinks.
*/
if(alloc_failed){
return YAFFS_FAIL;
}
-
+
T(YAFFS_TRACE_SCAN, (TSTR("yaffs_Scan ends" TENDSTR)));
-
+
return YAFFS_OK;
}
if(!in)
return;
-
+
#if 0
T(YAFFS_TRACE_SCAN,(TSTR("details for object %d %s loaded" TENDSTR),
in->objectId,
chunkData = yaffs_GetTempBuffer(dev, __LINE__);
result = yaffs_ReadChunkWithTagsFromNAND(dev,in->chunkId,chunkData,&tags);
- oh = (yaffs_ObjectHeader *) chunkData;
+ oh = (yaffs_ObjectHeader *) chunkData;
in->yst_mode = oh->yst_mode;
#ifdef CONFIG_YAFFS_WINCE
in->yst_mtime = oh->yst_mtime;
in->yst_ctime = oh->yst_ctime;
in->yst_rdev = oh->yst_rdev;
-
+
#endif
yaffs_SetObjectName(in, oh->name);
-
+
if(in->variantType == YAFFS_OBJECT_TYPE_SYMLINK){
in->variant.symLinkVariant.alias =
yaffs_CloneString(oh->alias);
if(!in->variant.symLinkVariant.alias)
alloc_failed = 1; /* Not returned to caller */
}
-
+
yaffs_ReleaseTempBuffer(dev,chunkData, __LINE__);
}
}
int nBlocks = dev->internalEndBlock - dev->internalStartBlock + 1;
int itsUnlinked;
__u8 *chunkData;
-
+
int fileSize;
int isShrink;
int foundChunksInBlock;
int equivalentObjectId;
int alloc_failed = 0;
-
+
yaffs_BlockIndex *blockIndex = NULL;
int altBlockIndex = 0;
dev->sequenceNumber = YAFFS_LOWEST_SEQUENCE_NUMBER;
blockIndex = YMALLOC(nBlocks * sizeof(yaffs_BlockIndex));
-
+
if(!blockIndex) {
blockIndex = YMALLOC_ALT(nBlocks * sizeof(yaffs_BlockIndex));
altBlockIndex = 1;
}
-
+
if(!blockIndex) {
T(YAFFS_TRACE_SCAN,
(TSTR("yaffs_Scan() could not allocate block index!" TENDSTR)));
return YAFFS_FAIL;
}
-
+
dev->blocksInCheckpoint = 0;
-
+
chunkData = yaffs_GetTempBuffer(dev, __LINE__);
/* Scan all the blocks to determine their state */
if(bi->sequenceNumber == YAFFS_SEQUENCE_CHECKPOINT_DATA)
bi->blockState = state = YAFFS_BLOCK_STATE_CHECKPOINT;
-
+
T(YAFFS_TRACE_SCAN_DEBUG,
(TSTR("Block scanning block %d state %d seq %d" TENDSTR), blk,
state, sequenceNumber));
-
+
if(state == YAFFS_BLOCK_STATE_CHECKPOINT){
dev->blocksInCheckpoint++;
-
+
} else if (state == YAFFS_BLOCK_STATE_DEAD) {
T(YAFFS_TRACE_BAD_BLOCKS,
(TSTR("block %d is bad" TENDSTR), blk));
#else
{
/* Dungy old bubble sort... */
-
+
yaffs_BlockIndex temp;
int i;
int j;
blk = blockIndex[blockIterator].block;
bi = yaffs_GetBlockInfo(dev, blk);
-
-
+
+
state = bi->blockState;
deleted = 0;
/* For each chunk in each block that needs scanning.... */
foundChunksInBlock = 0;
- for (c = dev->nChunksPerBlock - 1;
+ for (c = dev->nChunksPerBlock - 1;
!alloc_failed && c >= 0 &&
(state == YAFFS_BLOCK_STATE_NEEDS_SCANNING ||
state == YAFFS_BLOCK_STATE_ALLOCATING); c--) {
- /* Scan backwards...
+ /* Scan backwards...
* Read the tags and decide what to do
*/
-
+
chunk = blk * dev->nChunksPerBlock + c;
result = yaffs_ReadChunkWithTagsFromNAND(dev, chunk, NULL,
* it is a chunk that was skipped due to failing the erased
* check. Just skip it so that it can be deleted.
* But, more typically, We get here when this is an unallocated
- * chunk and his means that either the block is empty or
+ * chunk and his means that either the block is empty or
* this is the one being allocated from
*/
if(foundChunksInBlock)
{
/* This is a chunk that was skipped due to failing the erased check */
-
+
} else if (c == 0) {
/* We're looking at the first chunk in the block so the block is unused */
state = YAFFS_BLOCK_STATE_EMPTY;
state == YAFFS_BLOCK_STATE_ALLOCATING) {
if(dev->sequenceNumber == bi->sequenceNumber) {
/* this is the block being allocated from */
-
+
T(YAFFS_TRACE_SCAN,
(TSTR
(" Allocating from %d %d"
state = YAFFS_BLOCK_STATE_ALLOCATING;
dev->allocationBlock = blk;
dev->allocationPage = c;
- dev->allocationBlockFinder = blk;
+ dev->allocationBlockFinder = blk;
}
else {
/* This is a partially written block that is not
* the current allocation block. This block must have
* had a write failure, so set up for retirement.
*/
-
+
bi->needsRetiring = 1;
bi->gcPrioritise = 1;
-
+
T(YAFFS_TRACE_ALWAYS,
(TSTR("Partially written block %d being set for retirement" TENDSTR),
blk));
}
}
-
+
}
dev->nFreeChunks++;
-
+
} else if (tags.chunkId > 0) {
/* chunkId > 0 so it is a data chunk... */
unsigned int endpos;
__u32 chunkBase =
(tags.chunkId - 1) * dev->nDataBytesPerChunk;
-
+
foundChunksInBlock = 1;
/* Out of memory */
alloc_failed = 1;
}
-
+
if (in &&
in->variantType == YAFFS_OBJECT_TYPE_FILE
&& chunkBase <
alloc_failed = 1;
}
- /* File size is calculated by looking at the data chunks if we have not
+ /* File size is calculated by looking at the data chunks if we have not
* seen an object header yet. Stop this practice once we find an object header.
*/
endpos =
(tags.chunkId -
1) * dev->nDataBytesPerChunk +
tags.byteCount;
-
+
if (!in->valid && /* have not got an object header yet */
in->variant.fileVariant.
scannedFileSize < endpos) {
) {
/* If we don't have valid info then we need to read the chunk
- * TODO In future we can probably defer reading the chunk and
+ * TODO In future we can probably defer reading the chunk and
* living with invalid data until needed.
*/
if (in->valid) {
/* We have already filled this one.
- * We have a duplicate that will be discarded, but
+ * We have a duplicate that will be discarded, but
* we first have to suck out resize info if it is a file.
*/
- if ((in->variantType == YAFFS_OBJECT_TYPE_FILE) &&
- ((oh &&
+ if ((in->variantType == YAFFS_OBJECT_TYPE_FILE) &&
+ ((oh &&
oh-> type == YAFFS_OBJECT_TYPE_FILE)||
(tags.extraHeaderInfoAvailable &&
tags.extraObjectType == YAFFS_OBJECT_TYPE_FILE))
YAFFS_OBJECTID_LOSTNFOUND)) {
/* We only load some info, don't fiddle with directory structure */
in->valid = 1;
-
+
if(oh) {
in->variantType = oh->type;
in->yst_mtime = oh->yst_mtime;
in->yst_ctime = oh->yst_ctime;
in->yst_rdev = oh->yst_rdev;
-
+
#endif
} else {
in->variantType = tags.extraObjectType;
in->lazyLoaded = 1;
}
-
+
in->chunkId = chunk;
} else if (!in->valid) {
in->valid = 1;
in->chunkId = chunk;
-
+
if(oh) {
in->variantType = oh->type;
in->yst_rdev = oh->yst_rdev;
#endif
- if (oh->shadowsObject > 0)
+ if (oh->shadowsObject > 0)
yaffs_HandleShadowedObject(dev,
oh->
shadowsObject,
1);
-
+
yaffs_SetObjectName(in, oh->name);
parent =
* Since we might scan a hardlink before its equivalent object is scanned
* we put them all in a list.
* After scanning is complete, we should have all the objects, so we run
- * through this list and fix up all the chains.
+ * through this list and fix up all the chains.
*/
switch (in->variantType) {
- case YAFFS_OBJECT_TYPE_UNKNOWN:
+ case YAFFS_OBJECT_TYPE_UNKNOWN:
/* Todo got a problem */
break;
case YAFFS_OBJECT_TYPE_FILE:
scannedFileSize < fileSize) {
/* This covers the case where the file size is greater
* than where the data is
- * This will happen if the file is resized to be larger
+ * This will happen if the file is resized to be larger
* than its current data extents.
*/
in->variant.fileVariant.fileSize = fileSize;
}
}
-
+
}
} /* End of scanning for each chunk */
}
- if (altBlockIndex)
+ if (altBlockIndex)
YFREE_ALT(blockIndex);
else
YFREE(blockIndex);
-
+
/* Ok, we've done all the scanning.
* Fix up the hard link chains.
- * We should now have scanned all the objects, now it's time to add these
+ * We should now have scanned all the objects, now it's time to add these
* hardlinks.
*/
yaffs_HardlinkFixup(dev,hardList);
-
-
+
+
/*
* Sort out state of unlinked and deleted objects.
*/
}
yaffs_ReleaseTempBuffer(dev, chunkData, __LINE__);
-
+
if(alloc_failed){
return YAFFS_FAIL;
}
static void yaffs_RemoveObjectFromDirectory(yaffs_Object * obj)
{
yaffs_Device *dev = obj->myDev;
-
+
if(dev && dev->removeObjectCallback)
dev->removeObjectCallback(obj);
-
+
list_del_init(&obj->siblings);
obj->parent = NULL;
}
list_for_each(i, &directory->variant.directoryVariant.children) {
if (i) {
l = list_entry(i, yaffs_Object, siblings);
-
+
yaffs_CheckObjectDetailsLoaded(l);
/* Special case for lost-n-found */
if (yaffs_strcmp(name, YAFFS_LOSTNFOUND_NAME) == 0) {
return l;
}
- } else if (yaffs_SumCompare(l->sum, sum) || l->chunkId <= 0)
+ } else if (yaffs_SumCompare(l->sum, sum) || l->chunkId <= 0)
{
/* LostnFound cunk called Objxxx
* Do a real check
int yaffs_GetObjectName(yaffs_Object * obj, YCHAR * name, int buffSize)
{
memset(name, 0, buffSize * sizeof(YCHAR));
-
+
yaffs_CheckObjectDetailsLoaded(obj);
if (obj->objectId == YAFFS_OBJECTID_LOSTNFOUND) {
static int yaffs_CreateInitialDirectories(yaffs_Device *dev)
{
/* Initialise the unlinked, deleted, root and lost and found directories */
-
+
dev->lostNFoundDir = dev->rootDir = NULL;
dev->unlinkedDir = dev->deletedDir = NULL;
dev->unlinkedDir =
yaffs_CreateFakeDirectory(dev, YAFFS_OBJECTID_UNLINKED, S_IFDIR);
-
+
dev->deletedDir =
yaffs_CreateFakeDirectory(dev, YAFFS_OBJECTID_DELETED, S_IFDIR);
dev->lostNFoundDir =
yaffs_CreateFakeDirectory(dev, YAFFS_OBJECTID_LOSTNFOUND,
YAFFS_LOSTNFOUND_MODE | S_IFDIR);
-
+
if(dev->lostNFoundDir && dev->rootDir && dev->unlinkedDir && dev->deletedDir){
yaffs_AddObjectToDirectory(dev->rootDir, dev->lostNFoundDir);
return YAFFS_OK;
}
-
+
return YAFFS_FAIL;
}
/* Check geometry parameters. */
- if ((dev->isYaffs2 && dev->nDataBytesPerChunk < 1024) ||
- (!dev->isYaffs2 && dev->nDataBytesPerChunk != 512) ||
- dev->nChunksPerBlock < 2 ||
- dev->nReservedBlocks < 2 ||
- dev->internalStartBlock <= 0 ||
- dev->internalEndBlock <= 0 ||
+ if ((dev->isYaffs2 && dev->nDataBytesPerChunk < 1024) ||
+ (!dev->isYaffs2 && dev->nDataBytesPerChunk != 512) ||
+ dev->nChunksPerBlock < 2 ||
+ dev->nReservedBlocks < 2 ||
+ dev->internalStartBlock <= 0 ||
+ dev->internalEndBlock <= 0 ||
dev->internalEndBlock <= (dev->internalStartBlock + dev->nReservedBlocks + 2) // otherwise it is too small
) {
T(YAFFS_TRACE_ALWAYS,
/* OK now calculate a few things for the device */
-
+
/*
- * Calculate all the chunk size manipulation numbers:
+ * Calculate all the chunk size manipulation numbers:
*/
/* Start off assuming it is a power of 2 */
dev->chunkShift = ShiftDiv(dev->nDataBytesPerChunk);
dev->chunkShift = 0;
dev->chunkMask = 0;
}
-
+
/*
* Calculate chunkGroupBits.
*/
x = dev->nChunksPerBlock * (dev->internalEndBlock + 1);
-
+
bits = ShiftsGE(x);
-
+
/* Set up tnode width if wide tnodes are enabled. */
if(!dev->wideTnodesDisabled){
/* bits must be even so that we end up with 32-bit words */
}
else
dev->tnodeWidth = 16;
-
+
dev->tnodeMask = (1<<dev->tnodeWidth)-1;
-
+
/* Level0 Tnodes are 16 bits or wider (if wide tnodes are enabled),
* so if the bitwidth of the
* chunk range we're using is greater than 16 we need
* to figure out chunk shift and chunkGroupSize
*/
-
+
if (bits <= dev->tnodeWidth)
dev->chunkGroupBits = 0;
else
dev->chunkGroupBits = bits - dev->tnodeWidth;
-
+
dev->chunkGroupSize = 1 << dev->chunkGroupBits;
/* Initialise temporary buffers and caches. */
if(!yaffs_InitialiseTempBuffers(dev))
init_failed = 1;
-
+
dev->srCache = NULL;
dev->gcCleanupList = NULL;
-
-
+
+
if (!init_failed &&
dev->nShortOpCaches > 0) {
int i;
}
buf = dev->srCache = YMALLOC(srCacheBytes);
-
+
if(dev->srCache)
memset(dev->srCache,0,srCacheBytes);
-
+
for (i = 0; i < dev->nShortOpCaches && buf; i++) {
dev->srCache[i].object = NULL;
dev->srCache[i].lastUse = 0;
}
if(!buf)
init_failed = 1;
-
+
dev->srLastUse = 0;
}
dev->cacheHits = 0;
-
+
if(!init_failed){
dev->gcCleanupList = YMALLOC(dev->nChunksPerBlock * sizeof(__u32));
if(!dev->gcCleanupList)
}
if(!init_failed && !yaffs_InitialiseBlocks(dev))
init_failed = 1;
-
+
yaffs_InitialiseTnodes(dev);
yaffs_InitialiseObjects(dev);
(TSTR("yaffs: restored from checkpoint" TENDSTR)));
} else {
- /* Clean up the mess caused by an aborted checkpoint load
- * and scan backwards.
+ /* Clean up the mess caused by an aborted checkpoint load
+ * and scan backwards.
*/
yaffs_DeinitialiseBlocks(dev);
yaffs_DeinitialiseTnodes(dev);
yaffs_DeinitialiseObjects(dev);
-
-
+
+
dev->nErasedBlocks = 0;
dev->nFreeChunks = 0;
dev->allocationBlock = -1;
if(!init_failed && !yaffs_InitialiseBlocks(dev))
init_failed = 1;
-
+
yaffs_InitialiseTnodes(dev);
yaffs_InitialiseObjects(dev);
if(!yaffs_Scan(dev))
init_failed = 1;
}
-
+
if(init_failed){
/* Clean up the mess */
T(YAFFS_TRACE_TRACING,
yaffs_VerifyFreeChunks(dev);
yaffs_VerifyBlocks(dev);
-
+
T(YAFFS_TRACE_TRACING,
(TSTR("yaffs: yaffs_GutsInitialise() done.\n" TENDSTR)));
#endif
nFree += dev->nDeletedFiles;
-
+
/* Now count the number of dirty chunks in the cache and subtract those */
{
nFree -= nDirtyCacheChunks;
nFree -= ((dev->nReservedBlocks + 1) * dev->nChunksPerBlock);
-
+
/* Now we figure out how much to reserve for the checkpoint and report that... */
blocksForCheckpoint = dev->nCheckpointReservedBlocks - dev->blocksInCheckpoint;
if(blocksForCheckpoint < 0)
blocksForCheckpoint = 0;
-
+
nFree -= (blocksForCheckpoint * dev->nChunksPerBlock);
if (nFree < 0)
{
int counted;
int difference;
-
+
if(yaffs_SkipVerification(dev))
return;
-
+
counted = yaffs_CountFreeChunks(dev);
difference = dev->nFreeChunks - counted;
projects / openwrt.git / blobdiff