X-Git-Url: http://www.aleph1.co.uk/gitweb/?p=yaffs2.git;a=blobdiff_plain;f=yaffs_checkptrw.c;h=7ed37a03f038dbdc85535e2e51f1df13fd8599ea;hp=f56b311bbae4a814a4aeb836feccbad3bec214e5;hb=52191f6a41e2d965de7721c32546bf82150b5cc4;hpb=b9d0902ef84af3e242f6a95fb7a1b79e1eb94aa8 diff --git a/yaffs_checkptrw.c b/yaffs_checkptrw.c index f56b311..7ed37a0 100644 --- a/yaffs_checkptrw.c +++ b/yaffs_checkptrw.c @@ -1,7 +1,7 @@ /* - * YAFFS: Yet another FFS. A NAND-flash specific file system. + * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. * - * Copyright (C) 2002 Aleph One Ltd. + * Copyright (C) 2002-2007 Aleph One Ltd. * for Toby Churchill Ltd and Brightstar Engineering * * Created by Charles Manning @@ -9,47 +9,45 @@ * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. - * */ const char *yaffs_checkptrw_c_version = - "$Id: yaffs_checkptrw.c,v 1.3 2006-05-21 09:39:12 charles Exp $"; + "$Id: yaffs_checkptrw.c,v 1.17 2008-08-12 22:51:57 charles Exp $"; #include "yaffs_checkptrw.h" - +#include "yaffs_getblockinfo.h" static int yaffs_CheckpointSpaceOk(yaffs_Device *dev) { int blocksAvailable = dev->nErasedBlocks - dev->nReservedBlocks; - + T(YAFFS_TRACE_CHECKPOINT, (TSTR("checkpt blocks available = %d" TENDSTR), blocksAvailable)); - - + + return (blocksAvailable <= 0) ? 0 : 1; } - static int yaffs_CheckpointErase(yaffs_Device *dev) { - + int i; - - if(!dev->eraseBlockInNAND) + + if(!dev->eraseBlockInNAND) return 0; T(YAFFS_TRACE_CHECKPOINT,(TSTR("checking blocks %d to %d"TENDSTR), - dev->startBlock,dev->endBlock)); - - for(i = dev->startBlock; i <= dev->endBlock; i++) { - yaffs_BlockInfo *bi = &dev->blockInfo[i]; + dev->internalStartBlock,dev->internalEndBlock)); + + for(i = dev->internalStartBlock; i <= dev->internalEndBlock; i++) { + yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev,i); if(bi->blockState == YAFFS_BLOCK_STATE_CHECKPOINT){ T(YAFFS_TRACE_CHECKPOINT,(TSTR("erasing checkpt block %d"TENDSTR),i)); - if(dev->eraseBlockInNAND(dev,i)){ + if(dev->eraseBlockInNAND(dev,i- dev->blockOffset /* realign */)){ bi->blockState = YAFFS_BLOCK_STATE_EMPTY; dev->nErasedBlocks++; dev->nFreeChunks += dev->nChunksPerBlock; @@ -60,9 +58,9 @@ static int yaffs_CheckpointErase(yaffs_Device *dev) } } } - + dev->blocksInCheckpoint = 0; - + return 1; } @@ -71,16 +69,18 @@ static void yaffs_CheckpointFindNextErasedBlock(yaffs_Device *dev) { int i; int blocksAvailable = dev->nErasedBlocks - dev->nReservedBlocks; - + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("allocating checkpt block: erased %d reserved %d avail %d next %d "TENDSTR), + dev->nErasedBlocks,dev->nReservedBlocks,blocksAvailable,dev->checkpointNextBlock)); + if(dev->checkpointNextBlock >= 0 && - dev->checkpointNextBlock <= dev->endBlock && + dev->checkpointNextBlock <= dev->internalEndBlock && blocksAvailable > 0){ - - for(i = dev->checkpointNextBlock; i <= dev->endBlock; i++){ - yaffs_BlockInfo *bi = &dev->blockInfo[i]; + + for(i = dev->checkpointNextBlock; i <= dev->internalEndBlock; i++){ + yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev,i); if(bi->blockState == YAFFS_BLOCK_STATE_EMPTY){ dev->checkpointNextBlock = i + 1; - dev->nErasedBlocks--; dev->checkpointCurrentBlock = i; T(YAFFS_TRACE_CHECKPOINT,(TSTR("allocating checkpt block %d"TENDSTR),i)); return; @@ -88,7 +88,7 @@ static void yaffs_CheckpointFindNextErasedBlock(yaffs_Device *dev) } } T(YAFFS_TRACE_CHECKPOINT,(TSTR("out of checkpt blocks"TENDSTR))); - + dev->checkpointNextBlock = -1; dev->checkpointCurrentBlock = -1; } @@ -97,13 +97,19 @@ static void yaffs_CheckpointFindNextCheckpointBlock(yaffs_Device *dev) { int i; yaffs_ExtendedTags tags; - - if(dev->blocksInCheckpoint < dev->checkpointMaxBlocks) - for(i = dev->checkpointNextBlock; i <= dev->endBlock; i++){ + + T(YAFFS_TRACE_CHECKPOINT,(TSTR("find next checkpt block: start: blocks %d next %d" TENDSTR), + dev->blocksInCheckpoint, dev->checkpointNextBlock)); + + if(dev->blocksInCheckpoint < dev->checkpointMaxBlocks) + for(i = dev->checkpointNextBlock; i <= dev->internalEndBlock; i++){ int chunk = i * dev->nChunksPerBlock; + int realignedChunk = chunk - dev->chunkOffset; + + dev->readChunkWithTagsFromNAND(dev,realignedChunk,NULL,&tags); + T(YAFFS_TRACE_CHECKPOINT,(TSTR("find next checkpt block: search: block %d oid %d seq %d eccr %d" TENDSTR), + i, tags.objectId,tags.sequenceNumber,tags.eccResult)); - dev->readChunkWithTagsFromNAND(dev,chunk,NULL,&tags); - if(tags.sequenceNumber == YAFFS_SEQUENCE_CHECKPOINT_DATA){ /* Right kind of block */ dev->checkpointNextBlock = tags.objectId; @@ -124,7 +130,7 @@ static void yaffs_CheckpointFindNextCheckpointBlock(yaffs_Device *dev) int yaffs_CheckpointOpen(yaffs_Device *dev, int forWriting) { - + /* Got the functions we need? */ if (!dev->writeChunkWithTagsToNAND || !dev->readChunkWithTagsFromNAND || @@ -134,42 +140,52 @@ int yaffs_CheckpointOpen(yaffs_Device *dev, int forWriting) if(forWriting && !yaffs_CheckpointSpaceOk(dev)) return 0; - + if(!dev->checkpointBuffer) - dev->checkpointBuffer = YMALLOC(dev->nBytesPerChunk); + dev->checkpointBuffer = YMALLOC_DMA(dev->totalBytesPerChunk); if(!dev->checkpointBuffer) return 0; - + dev->checkpointPageSequence = 0; - + dev->checkpointOpenForWrite = forWriting; - + dev->checkpointByteCount = 0; + dev->checkpointSum = 0; + dev->checkpointXor = 0; dev->checkpointCurrentBlock = -1; dev->checkpointCurrentChunk = -1; - dev->checkpointNextBlock = dev->startBlock; - + dev->checkpointNextBlock = dev->internalStartBlock; + /* Erase all the blocks in the checkpoint area */ if(forWriting){ - memset(dev->checkpointBuffer,0,dev->nBytesPerChunk); + memset(dev->checkpointBuffer,0,dev->nDataBytesPerChunk); dev->checkpointByteOffset = 0; return yaffs_CheckpointErase(dev); - - + + } else { int i; /* Set to a value that will kick off a read */ - dev->checkpointByteOffset = dev->nBytesPerChunk; + dev->checkpointByteOffset = dev->nDataBytesPerChunk; /* A checkpoint block list of 1 checkpoint block per 16 block is (hopefully) * going to be way more than we need */ dev->blocksInCheckpoint = 0; - dev->checkpointMaxBlocks = (dev->endBlock - dev->startBlock)/16 + 2; + dev->checkpointMaxBlocks = (dev->internalEndBlock - dev->internalStartBlock)/16 + 2; dev->checkpointBlockList = YMALLOC(sizeof(int) * dev->checkpointMaxBlocks); for(i = 0; i < dev->checkpointMaxBlocks; i++) dev->checkpointBlockList[i] = -1; } - + + return 1; +} + +int yaffs_GetCheckpointSum(yaffs_Device *dev, __u32 *sum) +{ + __u32 compositeSum; + compositeSum = (dev->checkpointSum << 8) | (dev->checkpointXor & 0xFF); + *sum = compositeSum; return 1; } @@ -177,35 +193,49 @@ static int yaffs_CheckpointFlushBuffer(yaffs_Device *dev) { int chunk; + int realignedChunk; yaffs_ExtendedTags tags; - + if(dev->checkpointCurrentBlock < 0){ yaffs_CheckpointFindNextErasedBlock(dev); dev->checkpointCurrentChunk = 0; } - + if(dev->checkpointCurrentBlock < 0) return 0; - + tags.chunkDeleted = 0; tags.objectId = dev->checkpointNextBlock; /* Hint to next place to look */ tags.chunkId = dev->checkpointPageSequence + 1; tags.sequenceNumber = YAFFS_SEQUENCE_CHECKPOINT_DATA; - tags.byteCount = dev->nBytesPerChunk; - + tags.byteCount = dev->nDataBytesPerChunk; + if(dev->checkpointCurrentChunk == 0){ + /* First chunk we write for the block? Set block state to + checkpoint */ + yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev,dev->checkpointCurrentBlock); + bi->blockState = YAFFS_BLOCK_STATE_CHECKPOINT; + dev->blocksInCheckpoint++; + } + chunk = dev->checkpointCurrentBlock * dev->nChunksPerBlock + dev->checkpointCurrentChunk; - - dev->writeChunkWithTagsToNAND(dev,chunk,dev->checkpointBuffer,&tags); + + + T(YAFFS_TRACE_CHECKPOINT,(TSTR("checkpoint wite buffer nand %d(%d:%d) objid %d chId %d" TENDSTR), + chunk, dev->checkpointCurrentBlock, dev->checkpointCurrentChunk,tags.objectId,tags.chunkId)); + + realignedChunk = chunk - dev->chunkOffset; + + dev->writeChunkWithTagsToNAND(dev,realignedChunk,dev->checkpointBuffer,&tags); dev->checkpointByteOffset = 0; - dev->checkpointPageSequence++; + dev->checkpointPageSequence++; dev->checkpointCurrentChunk++; if(dev->checkpointCurrentChunk >= dev->nChunksPerBlock){ dev->checkpointCurrentChunk = 0; dev->checkpointCurrentBlock = -1; } - memset(dev->checkpointBuffer,0,dev->nBytesPerChunk); - + memset(dev->checkpointBuffer,0,dev->nDataBytesPerChunk); + return 1; } @@ -215,31 +245,37 @@ int yaffs_CheckpointWrite(yaffs_Device *dev,const void *data, int nBytes) int i=0; int ok = 1; - + __u8 * dataBytes = (__u8 *)data; - - + + if(!dev->checkpointBuffer) return 0; + if(!dev->checkpointOpenForWrite) + return -1; + while(i < nBytes && ok) { - - - dev->checkpointBuffer[dev->checkpointByteOffset] = *dataBytes ; + + + dev->checkpointBuffer[dev->checkpointByteOffset] = *dataBytes ; + dev->checkpointSum += *dataBytes; + dev->checkpointXor ^= *dataBytes; + dev->checkpointByteOffset++; i++; dataBytes++; dev->checkpointByteCount++; - - + + if(dev->checkpointByteOffset < 0 || - dev->checkpointByteOffset >= dev->nBytesPerChunk) + dev->checkpointByteOffset >= dev->nDataBytesPerChunk) ok = yaffs_CheckpointFlushBuffer(dev); } - + return i; } @@ -249,73 +285,82 @@ int yaffs_CheckpointRead(yaffs_Device *dev, void *data, int nBytes) int ok = 1; yaffs_ExtendedTags tags; - + int chunk; + int realignedChunk; __u8 *dataBytes = (__u8 *)data; - + if(!dev->checkpointBuffer) return 0; + if(dev->checkpointOpenForWrite) + return -1; + while(i < nBytes && ok) { - - + + if(dev->checkpointByteOffset < 0 || - dev->checkpointByteOffset >= dev->nBytesPerChunk) { - + dev->checkpointByteOffset >= dev->nDataBytesPerChunk) { + if(dev->checkpointCurrentBlock < 0){ yaffs_CheckpointFindNextCheckpointBlock(dev); dev->checkpointCurrentChunk = 0; } - + if(dev->checkpointCurrentBlock < 0) ok = 0; else { - - chunk = dev->checkpointCurrentBlock * dev->nChunksPerBlock + + + chunk = dev->checkpointCurrentBlock * dev->nChunksPerBlock + dev->checkpointCurrentChunk; + realignedChunk = chunk - dev->chunkOffset; + /* read in the next chunk */ /* printf("read checkpoint page %d\n",dev->checkpointPage); */ - dev->readChunkWithTagsFromNAND(dev, chunk, + dev->readChunkWithTagsFromNAND(dev, realignedChunk, dev->checkpointBuffer, &tags); - + if(tags.chunkId != (dev->checkpointPageSequence + 1) || + tags.eccResult > YAFFS_ECC_RESULT_FIXED || tags.sequenceNumber != YAFFS_SEQUENCE_CHECKPOINT_DATA) ok = 0; dev->checkpointByteOffset = 0; dev->checkpointPageSequence++; dev->checkpointCurrentChunk++; - + if(dev->checkpointCurrentChunk >= dev->nChunksPerBlock) dev->checkpointCurrentBlock = -1; } } - + if(ok){ *dataBytes = dev->checkpointBuffer[dev->checkpointByteOffset]; + dev->checkpointSum += *dataBytes; + dev->checkpointXor ^= *dataBytes; dev->checkpointByteOffset++; i++; dataBytes++; dev->checkpointByteCount++; } } - + return i; } int yaffs_CheckpointClose(yaffs_Device *dev) { - if(dev->checkpointOpenForWrite){ + if(dev->checkpointOpenForWrite){ if(dev->checkpointByteOffset != 0) yaffs_CheckpointFlushBuffer(dev); } else { int i; for(i = 0; i < dev->blocksInCheckpoint && dev->checkpointBlockList[i] >= 0; i++){ - yaffs_BlockInfo *bi = &dev->blockInfo[dev->checkpointBlockList[i]]; + yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev,dev->checkpointBlockList[i]); if(bi->blockState == YAFFS_BLOCK_STATE_EMPTY) bi->blockState = YAFFS_BLOCK_STATE_CHECKPOINT; else { @@ -329,19 +374,19 @@ int yaffs_CheckpointClose(yaffs_Device *dev) dev->nFreeChunks -= dev->blocksInCheckpoint * dev->nChunksPerBlock; dev->nErasedBlocks -= dev->blocksInCheckpoint; - + T(YAFFS_TRACE_CHECKPOINT,(TSTR("checkpoint byte count %d" TENDSTR), dev->checkpointByteCount)); - + if(dev->checkpointBuffer){ - /* free the buffer */ + /* free the buffer */ YFREE(dev->checkpointBuffer); dev->checkpointBuffer = NULL; return 1; } else return 0; - + } int yaffs_CheckpointInvalidateStream(yaffs_Device *dev)