/* * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. * * Copyright (C) 2002-2007 Aleph One Ltd. * for Toby Churchill Ltd and Brightstar Engineering * * Created by Charles Manning <charles@aleph1.co.uk> * * 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.14 2007-05-15 20:07:40 charles Exp $"; #include "yaffs_checkptrw.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) return 0; T(YAFFS_TRACE_CHECKPOINT,(TSTR("checking blocks %d to %d"TENDSTR), 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- 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) { /* Got the functions we need? */ if (!dev->writeChunkWithTagsToNAND || !dev->readChunkWithTagsFromNAND || !dev->eraseBlockInNAND || !dev->markNANDBlockBad) return 0; if(forWriting && !yaffs_CheckpointSpaceOk(dev)) return 0; if(!dev->checkpointBuffer) dev->checkpointBuffer = YMALLOC_DMA(dev->nDataBytesPerChunk); 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->internalStartBlock; /* Erase all the blocks in the checkpoint area */ if(forWriting){ 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->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; } int yaffs_GetCheckpointSum(yaffs_Device *dev, __u32 *sum) { __u32 compositeSum; compositeSum = (dev->checkpointSum << 8) | (dev->checkpointXor & 0xFF); *sum = compositeSum; return 1; } 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->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; 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->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; 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->checkpointSum += *dataBytes; dev->checkpointXor ^= *dataBytes; dev->checkpointByteOffset++; i++; dataBytes++; dev->checkpointByteCount++; if(dev->checkpointByteOffset < 0 || dev->checkpointByteOffset >= dev->nDataBytesPerChunk) ok = yaffs_CheckpointFlushBuffer(dev); } return i; } int yaffs_CheckpointRead(yaffs_Device *dev, void *data, int nBytes) { int i=0; 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->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, realignedChunk, dev->checkpointBuffer, &tags); if(tags.chunkId != (dev->checkpointPageSequence + 1) || 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->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){ /* free the buffer */ YFREE(dev->checkpointBuffer); dev->checkpointBuffer = NULL; return 1; } else return 0; } int yaffs_CheckpointInvalidateStream(yaffs_Device *dev) { /* Erase the first checksum block */ T(YAFFS_TRACE_CHECKPOINT,(TSTR("checkpoint invalidate"TENDSTR))); if(!yaffs_CheckpointSpaceOk(dev)) return 0; return yaffs_CheckpointErase(dev); }