X-Git-Url: http://www.aleph1.co.uk/gitweb/?p=yaffs2.git;a=blobdiff_plain;f=yaffs_checkptrw.c;h=2f658e68aadacf37eca09f30e34bb584e018cd5a;hp=12d3cea480976f9f1ca6e4070973e4cb10a06b0f;hb=e1ac494e05a5dc7ab61d799af815d103a11d318c;hpb=e1b8e63260986ab7afec3c379e7a320677c95846 diff --git a/yaffs_checkptrw.c b/yaffs_checkptrw.c index 12d3cea..2f658e6 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,75 +9,172 @@ * 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.1 2006-05-08 10:13:34 charles Exp $"; + "$Id: yaffs_checkptrw.c,v 1.13 2007-02-14 01:09:06 wookey Exp $"; #include "yaffs_checkptrw.h" -int yaffs_CheckpointSpaceOk(yaffs_Device *dev) +static int yaffs_CheckpointSpaceOk(yaffs_Device *dev) { - T(YAFFS_TRACE_CHECKPOINT,(TSTR("checkpt blocks %d %d %d %d" TENDSTR), - dev->checkpointStartBlock, dev->checkpointEndBlock, - dev->startBlock,dev->endBlock)); + int blocksAvailable = dev->nErasedBlocks - dev->nReservedBlocks; + + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("checkpt blocks available = %d" TENDSTR), + blocksAvailable)); - if(dev->checkpointStartBlock >= dev->checkpointEndBlock) + + return (blocksAvailable <= 0) ? 0 : 1; +} + + + +static int yaffs_CheckpointErase(yaffs_Device *dev) +{ + + int i; + + + if(!dev->eraseBlockInNAND) return 0; + T(YAFFS_TRACE_CHECKPOINT,(TSTR("checking blocks %d to %d"TENDSTR), + dev->internalStartBlock,dev->internalEndBlock)); - if(dev->checkpointStartBlock >= dev->startBlock && - dev->checkpointStartBlock <= dev->endBlock) - return 0; - - if(dev->checkpointEndBlock >= dev->startBlock && - dev->checkpointEndBlock <= dev->endBlock) - return 0; - + 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- dev->blockOffset /* realign */)){ + bi->blockState = YAFFS_BLOCK_STATE_EMPTY; + dev->nErasedBlocks++; + dev->nFreeChunks += dev->nChunksPerBlock; + } + else { + dev->markNANDBlockBad(dev,i); + bi->blockState = YAFFS_BLOCK_STATE_DEAD; + } + } + } + + dev->blocksInCheckpoint = 0; + return 1; } + +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->internalEndBlock && + blocksAvailable > 0){ + + 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->checkpointCurrentBlock = i; + T(YAFFS_TRACE_CHECKPOINT,(TSTR("allocating checkpt block %d"TENDSTR),i)); + return; + } + } + } + T(YAFFS_TRACE_CHECKPOINT,(TSTR("out of checkpt blocks"TENDSTR))); + + dev->checkpointNextBlock = -1; + dev->checkpointCurrentBlock = -1; +} + +static void yaffs_CheckpointFindNextCheckpointBlock(yaffs_Device *dev) +{ + int i; + yaffs_ExtendedTags tags; + + 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)); + + if(tags.sequenceNumber == YAFFS_SEQUENCE_CHECKPOINT_DATA){ + /* Right kind of block */ + dev->checkpointNextBlock = tags.objectId; + dev->checkpointCurrentBlock = i; + dev->checkpointBlockList[dev->blocksInCheckpoint] = i; + dev->blocksInCheckpoint++; + T(YAFFS_TRACE_CHECKPOINT,(TSTR("found checkpt block %d"TENDSTR),i)); + return; + } + } + + T(YAFFS_TRACE_CHECKPOINT,(TSTR("found no more checkpt blocks"TENDSTR))); + + dev->checkpointNextBlock = -1; + dev->checkpointCurrentBlock = -1; +} + + int yaffs_CheckpointOpen(yaffs_Device *dev, int forWriting) { - int i; /* Got the functions we need? */ if (!dev->writeChunkWithTagsToNAND || !dev->readChunkWithTagsFromNAND || - !dev->eraseBlockInNAND) + !dev->eraseBlockInNAND || + !dev->markNANDBlockBad) return 0; - - /* Got a valid checkpoint data region? */ - if(!yaffs_CheckpointSpaceOk(dev)) + + if(forWriting && !yaffs_CheckpointSpaceOk(dev)) return 0; if(!dev->checkpointBuffer) - dev->checkpointBuffer = YMALLOC(dev->nBytesPerChunk); + dev->checkpointBuffer = YMALLOC_DMA(dev->nDataBytesPerChunk); if(!dev->checkpointBuffer) return 0; + - dev->checkpointPage = dev->checkpointStartBlock * dev->nChunksPerBlock; + dev->checkpointPageSequence = 0; dev->checkpointOpenForWrite = forWriting; dev->checkpointByteCount = 0; + dev->checkpointCurrentBlock = -1; + dev->checkpointCurrentChunk = -1; + dev->checkpointNextBlock = dev->internalStartBlock; /* Erase all the blocks in the checkpoint area */ if(forWriting){ - T(YAFFS_TRACE_CHECKPOINT,(TSTR("erasing checkpt data"TENDSTR))); - for( i = dev->checkpointStartBlock; i <= dev->checkpointEndBlock; i++) - dev->eraseBlockInNAND(dev,i); - + memset(dev->checkpointBuffer,0,dev->nDataBytesPerChunk); dev->checkpointByteOffset = 0; + return yaffs_CheckpointErase(dev); - memset(dev->checkpointBuffer,0,dev->nBytesPerChunk); } 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->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; @@ -86,47 +183,54 @@ int yaffs_CheckpointOpen(yaffs_Device *dev, int forWriting) static int yaffs_CheckpointFlushBuffer(yaffs_Device *dev) { - int blockNo; - int goodBlockFound; - yaffs_BlockState state; - __u32 seqenceNumber; + 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 = YAFFS_OBJECTID_CHECKPOINT_DATA; - tags.chunkId = dev->checkpointPage + 1; - tags.sequenceNumber = 1; - tags.byteCount = dev->nBytesPerChunk; - - /* printf("write checkpoint page %d\n",dev->checkpointPage); */ - - if(dev->checkpointPage%dev->nChunksPerBlock == 0){ - /* Start of a new block, do a block validity check */ - blockNo = dev->checkpointPage/dev->nChunksPerBlock; - goodBlockFound = 0; - while(blockNo <= dev->checkpointEndBlock && !goodBlockFound){ - dev->queryNANDBlock(dev,blockNo,&state,&tags); - if(state != YAFFS_BLOCK_STATE_DEAD) - goodBlockFound = 1; - else { - blockNo++; - dev->checkpointPage += dev->nChunksPerBlock; - } - } - - if(!goodBlockFound) - return 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->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++; } - dev->writeChunkWithTagsToNAND(dev, dev->checkpointPage, - dev->checkpointBuffer,&tags); + chunk = dev->checkpointCurrentBlock * dev->nChunksPerBlock + dev->checkpointCurrentChunk; + + + 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->checkpointPage++; - memset(dev->checkpointBuffer,0,dev->nBytesPerChunk); + dev->checkpointPageSequence++; + dev->checkpointCurrentChunk++; + if(dev->checkpointCurrentChunk >= dev->nChunksPerBlock){ + dev->checkpointCurrentChunk = 0; + dev->checkpointCurrentBlock = -1; + } + memset(dev->checkpointBuffer,0,dev->nDataBytesPerChunk); return 1; } + int yaffs_CheckpointWrite(yaffs_Device *dev,const void *data, int nBytes) { int i=0; @@ -152,7 +256,7 @@ int yaffs_CheckpointWrite(yaffs_Device *dev,const void *data, int nBytes) if(dev->checkpointByteOffset < 0 || - dev->checkpointByteOffset >= dev->nBytesPerChunk) + dev->checkpointByteOffset >= dev->nDataBytesPerChunk) ok = yaffs_CheckpointFlushBuffer(dev); } @@ -165,9 +269,10 @@ int yaffs_CheckpointRead(yaffs_Device *dev, void *data, int nBytes) int i=0; int ok = 1; yaffs_ExtendedTags tags; - yaffs_BlockState state; - int blockNo; - int goodBlockFound; + + + int chunk; + int realignedChunk; __u8 *dataBytes = (__u8 *)data; @@ -175,39 +280,42 @@ int yaffs_CheckpointRead(yaffs_Device *dev, void *data, int nBytes) return 0; while(i < nBytes && ok) { + + if(dev->checkpointByteOffset < 0 || - dev->checkpointByteOffset >= dev->nBytesPerChunk) { - if(dev->checkpointPage%dev->nChunksPerBlock == 0){ - /* Start of a new block, do a block validity check */ - blockNo = dev->checkpointPage/dev->nChunksPerBlock; - goodBlockFound = 0; - while(blockNo <= dev->checkpointEndBlock && !goodBlockFound){ - dev->queryNANDBlock(dev,blockNo,&state,&tags); - if(state != YAFFS_BLOCK_STATE_DEAD) - goodBlockFound = 1; - else { - blockNo++; - dev->checkpointPage += dev->nChunksPerBlock; - } - } - - if(!goodBlockFound) - return 0; + 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 + + dev->checkpointCurrentChunk; + realignedChunk = chunk - dev->chunkOffset; - /* read in the next chunk */ - /* printf("read checkpoint page %d\n",dev->checkpointPage); */ - dev->readChunkWithTagsFromNAND(dev, dev->checkpointPage, - dev->checkpointBuffer, - &tags); + /* read in the next chunk */ + /* printf("read checkpoint page %d\n",dev->checkpointPage); */ + dev->readChunkWithTagsFromNAND(dev, realignedChunk, + dev->checkpointBuffer, + &tags); - if(tags.objectId != YAFFS_OBJECTID_CHECKPOINT_DATA || - tags.chunkId != (dev->checkpointPage + 1)) - ok = 0; + if(tags.chunkId != (dev->checkpointPageSequence + 1) || + tags.sequenceNumber != YAFFS_SEQUENCE_CHECKPOINT_DATA) + ok = 0; - dev->checkpointByteOffset = 0; - dev->checkpointPage++; + dev->checkpointByteOffset = 0; + dev->checkpointPageSequence++; + dev->checkpointCurrentChunk++; + + if(dev->checkpointCurrentChunk >= dev->nChunksPerBlock) + dev->checkpointCurrentBlock = -1; + } } if(ok){ @@ -228,13 +336,29 @@ int yaffs_CheckpointClose(yaffs_Device *dev) 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 = yaffs_GetBlockInfo(dev,dev->checkpointBlockList[i]); + if(bi->blockState == YAFFS_BLOCK_STATE_EMPTY) + bi->blockState = YAFFS_BLOCK_STATE_CHECKPOINT; + else { + // Todo this looks odd... + } + } + YFREE(dev->checkpointBlockList); + dev->checkpointBlockList = NULL; } + 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){ - /* flush the buffer */ + /* free the buffer */ YFREE(dev->checkpointBuffer); dev->checkpointBuffer = NULL; return 1; @@ -253,13 +377,7 @@ int yaffs_CheckpointInvalidateStream(yaffs_Device *dev) if(!yaffs_CheckpointSpaceOk(dev)) return 0; - if(dev->eraseBlockInNAND){ - T(YAFFS_TRACE_CHECKPOINT,(TSTR("erasing checkpt data"TENDSTR))); - - return dev->eraseBlockInNAND(dev, dev->checkpointStartBlock); - } - else - return 0; + return yaffs_CheckpointErase(dev); }