yaffs_checkptrw.c

   1 /* YAFFS: Yet another FFS. A NAND-flash specific file system.
   2  *
   3  * Copyright (C) 2002 Aleph One Ltd.
   4  *   for Toby Churchill Ltd and Brightstar Engineering
   5  *
   6  * Created by Charles Manning <charles@aleph1.co.uk>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundation.
  11  *
  12  */
  13
  14 const char *yaffs_checkptrw_c_version =
  15     "$Id: yaffs_checkptrw.c,v 1.10 2006-11-10 02:51:10 charles Exp $";
  16
  17
  18 #include "yaffs_checkptrw.h"
  19
  20
  21 static int yaffs_CheckpointSpaceOk(yaffs_Device *dev)
  22 {
  23
  24         int blocksAvailable = dev->nErasedBlocks - dev->nReservedBlocks;
  25
  26         T(YAFFS_TRACE_CHECKPOINT,
  27                 (TSTR("checkpt blocks available = %d" TENDSTR),
  28                 blocksAvailable));
  29
  30
  31         return (blocksAvailable <= 0) ? 0 : 1;
  32 }
  33
  34
  35
  36 static int yaffs_CheckpointErase(yaffs_Device *dev)
  37 {
  38
  39         int i;
  40
  41
  42         if(!dev->eraseBlockInNAND)
  43                 return 0;
  44         T(YAFFS_TRACE_CHECKPOINT,(TSTR("checking blocks %d to %d"TENDSTR),
  45                 dev->internalStartBlock,dev->internalEndBlock));
  46
  47         for(i = dev->internalStartBlock; i <= dev->internalEndBlock; i++) {
  48                 yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev,i);
  49                 if(bi->blockState == YAFFS_BLOCK_STATE_CHECKPOINT){
  50                         T(YAFFS_TRACE_CHECKPOINT,(TSTR("erasing checkpt block %d"TENDSTR),i));
  51                         if(dev->eraseBlockInNAND(dev,i)){
  52                                 bi->blockState = YAFFS_BLOCK_STATE_EMPTY;
  53                                 dev->nErasedBlocks++;
  54                                 dev->nFreeChunks += dev->nChunksPerBlock;
  55                         }
  56                         else {
  57                                 dev->markNANDBlockBad(dev,i);
  58                                 bi->blockState = YAFFS_BLOCK_STATE_DEAD;
  59                         }
  60                 }
  61         }
  62
  63         dev->blocksInCheckpoint = 0;
  64
  65         return 1;
  66 }
  67
  68
  69 static void yaffs_CheckpointFindNextErasedBlock(yaffs_Device *dev)
  70 {
  71         int  i;
  72         int blocksAvailable = dev->nErasedBlocks - dev->nReservedBlocks;
  73         T(YAFFS_TRACE_CHECKPOINT,
  74                 (TSTR("allocating checkpt block: erased %d reserved %d avail %d next %d "TENDSTR),
  75                 dev->nErasedBlocks,dev->nReservedBlocks,blocksAvailable,dev->checkpointNextBlock));
  76
  77         if(dev->checkpointNextBlock >= 0 &&
  78            dev->checkpointNextBlock <= dev->internalEndBlock &&
  79            blocksAvailable > 0){
  80
  81                 for(i = dev->checkpointNextBlock; i <= dev->internalEndBlock; i++){
  82                         yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev,i);
  83                         if(bi->blockState == YAFFS_BLOCK_STATE_EMPTY){
  84                                 dev->checkpointNextBlock = i + 1;
  85                                 dev->checkpointCurrentBlock = i;
  86                                 T(YAFFS_TRACE_CHECKPOINT,(TSTR("allocating checkpt block %d"TENDSTR),i));
  87                                 return;
  88                         }
  89                 }
  90         }
  91         T(YAFFS_TRACE_CHECKPOINT,(TSTR("out of checkpt blocks"TENDSTR)));
  92
  93         dev->checkpointNextBlock = -1;
  94         dev->checkpointCurrentBlock = -1;
  95 }
  96
  97 static void yaffs_CheckpointFindNextCheckpointBlock(yaffs_Device *dev)
  98 {
  99         int  i;
 100         yaffs_ExtendedTags tags;
 101
 102         T(YAFFS_TRACE_CHECKPOINT,(TSTR("find next checkpt block: start:  blocks %d next %d" TENDSTR),
 103                 dev->blocksInCheckpoint, dev->checkpointNextBlock));
 104
 105         if(dev->blocksInCheckpoint < dev->checkpointMaxBlocks)
 106                 for(i = dev->checkpointNextBlock; i <= dev->internalEndBlock; i++){
 107                         int chunk = i * dev->nChunksPerBlock;
 108
 109                         dev->readChunkWithTagsFromNAND(dev,chunk,NULL,&tags);
 110                         T(YAFFS_TRACE_CHECKPOINT,(TSTR("find next checkpt block: search: block %d oid %d seq %d eccr %d" TENDSTR),
 111                                 i, tags.objectId,tags.sequenceNumber,tags.eccResult));
 112
 113                         if(tags.sequenceNumber == YAFFS_SEQUENCE_CHECKPOINT_DATA){
 114                                 /* Right kind of block */
 115                                 dev->checkpointNextBlock = tags.objectId;
 116                                 dev->checkpointCurrentBlock = i;
 117                                 dev->checkpointBlockList[dev->blocksInCheckpoint] = i;
 118                                 dev->blocksInCheckpoint++;
 119                                 T(YAFFS_TRACE_CHECKPOINT,(TSTR("found checkpt block %d"TENDSTR),i));
 120                                 return;
 121                         }
 122                 }
 123
 124         T(YAFFS_TRACE_CHECKPOINT,(TSTR("found no more checkpt blocks"TENDSTR)));
 125
 126         dev->checkpointNextBlock = -1;
 127         dev->checkpointCurrentBlock = -1;
 128 }
 129
 130
 131 int yaffs_CheckpointOpen(yaffs_Device *dev, int forWriting)
 132 {
 133
 134         /* Got the functions we need? */
 135         if (!dev->writeChunkWithTagsToNAND ||
 136             !dev->readChunkWithTagsFromNAND ||
 137             !dev->eraseBlockInNAND ||
 138             !dev->markNANDBlockBad)
 139                 return 0;
 140
 141         if(forWriting && !yaffs_CheckpointSpaceOk(dev))
 142                 return 0;
 143
 144         if(!dev->checkpointBuffer)
 145                 dev->checkpointBuffer = YMALLOC_DMA(dev->nDataBytesPerChunk);
 146         if(!dev->checkpointBuffer)
 147                 return 0;
 148
 149
 150         dev->checkpointPageSequence = 0;
 151
 152         dev->checkpointOpenForWrite = forWriting;
 153
 154         dev->checkpointByteCount = 0;
 155         dev->checkpointCurrentBlock = -1;
 156         dev->checkpointCurrentChunk = -1;
 157         dev->checkpointNextBlock = dev->internalStartBlock;
 158
 159         /* Erase all the blocks in the checkpoint area */
 160         if(forWriting){
 161                 memset(dev->checkpointBuffer,0,dev->nDataBytesPerChunk);
 162                 dev->checkpointByteOffset = 0;
 163                 return yaffs_CheckpointErase(dev);
 164
 165
 166         } else {
 167                 int i;
 168                 /* Set to a value that will kick off a read */
 169                 dev->checkpointByteOffset = dev->nDataBytesPerChunk;
 170                 /* A checkpoint block list of 1 checkpoint block per 16 block is (hopefully)
 171                  * going to be way more than we need */
 172                 dev->blocksInCheckpoint = 0;
 173                 dev->checkpointMaxBlocks = (dev->internalEndBlock - dev->internalStartBlock)/16 + 2;
 174                 dev->checkpointBlockList = YMALLOC(sizeof(int) * dev->checkpointMaxBlocks);
 175                 for(i = 0; i < dev->checkpointMaxBlocks; i++)
 176                         dev->checkpointBlockList[i] = -1;
 177         }
 178
 179         return 1;
 180 }
 181
 182 static int yaffs_CheckpointFlushBuffer(yaffs_Device *dev)
 183 {
 184
 185         int chunk;
 186
 187         yaffs_ExtendedTags tags;
 188
 189         if(dev->checkpointCurrentBlock < 0){
 190                 yaffs_CheckpointFindNextErasedBlock(dev);
 191                 dev->checkpointCurrentChunk = 0;
 192         }
 193
 194         if(dev->checkpointCurrentBlock < 0)
 195                 return 0;
 196
 197         tags.chunkDeleted = 0;
 198         tags.objectId = dev->checkpointNextBlock; /* Hint to next place to look */
 199         tags.chunkId = dev->checkpointPageSequence + 1;
 200         tags.sequenceNumber =  YAFFS_SEQUENCE_CHECKPOINT_DATA;
 201         tags.byteCount = dev->nDataBytesPerChunk;
 202         if(dev->checkpointCurrentChunk == 0){
 203                 /* First chunk we write for the block? Set block state to
 204                    checkpoint */
 205                 yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev,dev->checkpointCurrentBlock);
 206                 bi->blockState = YAFFS_BLOCK_STATE_CHECKPOINT;
 207                 dev->blocksInCheckpoint++;
 208         }
 209
 210         chunk = dev->checkpointCurrentBlock * dev->nChunksPerBlock + dev->checkpointCurrentChunk;
 211
 212         T(YAFFS_TRACE_CHECKPOINT,(TSTR("checkpoint wite buffer nand %d(%d:%d) objid %d chId %d" TENDSTR),
 213                 chunk, dev->checkpointCurrentBlock, dev->checkpointCurrentChunk,tags.objectId,tags.chunkId));
 214
 215         dev->writeChunkWithTagsToNAND(dev,chunk,dev->checkpointBuffer,&tags);
 216         dev->checkpointByteOffset = 0;
 217         dev->checkpointPageSequence++;
 218         dev->checkpointCurrentChunk++;
 219         if(dev->checkpointCurrentChunk >= dev->nChunksPerBlock){
 220                 dev->checkpointCurrentChunk = 0;
 221                 dev->checkpointCurrentBlock = -1;
 222         }
 223         memset(dev->checkpointBuffer,0,dev->nDataBytesPerChunk);
 224
 225         return 1;
 226 }
 227
 228
 229 int yaffs_CheckpointWrite(yaffs_Device *dev,const void *data, int nBytes)
 230 {
 231         int i=0;
 232         int ok = 1;
 233
 234
 235         __u8 * dataBytes = (__u8 *)data;
 236
 237
 238
 239         if(!dev->checkpointBuffer)
 240                 return 0;
 241
 242         while(i < nBytes && ok) {
 243
 244
 245
 246                  dev->checkpointBuffer[dev->checkpointByteOffset] = *dataBytes ;
 247                 dev->checkpointByteOffset++;
 248                 i++;
 249                 dataBytes++;
 250                 dev->checkpointByteCount++;
 251
 252
 253                 if(dev->checkpointByteOffset < 0 ||
 254                    dev->checkpointByteOffset >= dev->nDataBytesPerChunk)
 255                         ok = yaffs_CheckpointFlushBuffer(dev);
 256
 257         }
 258
 259         return  i;
 260 }
 261
 262 int yaffs_CheckpointRead(yaffs_Device *dev, void *data, int nBytes)
 263 {
 264         int i=0;
 265         int ok = 1;
 266         yaffs_ExtendedTags tags;
 267
 268
 269         int chunk;
 270
 271         __u8 *dataBytes = (__u8 *)data;
 272
 273         if(!dev->checkpointBuffer)
 274                 return 0;
 275
 276         while(i < nBytes && ok) {
 277
 278
 279                 if(dev->checkpointByteOffset < 0 ||
 280                    dev->checkpointByteOffset >= dev->nDataBytesPerChunk) {
 281
 282                         if(dev->checkpointCurrentBlock < 0){
 283                                 yaffs_CheckpointFindNextCheckpointBlock(dev);
 284                                 dev->checkpointCurrentChunk = 0;
 285                         }
 286
 287                         if(dev->checkpointCurrentBlock < 0)
 288                                 ok = 0;
 289                         else {
 290
 291                                 chunk = dev->checkpointCurrentBlock * dev->nChunksPerBlock +
 292                                           dev->checkpointCurrentChunk;
 293
 294                                 /* read in the next chunk */
 295                                 /* printf("read checkpoint page %d\n",dev->checkpointPage); */
 296                                 dev->readChunkWithTagsFromNAND(dev, chunk,
 297                                                                dev->checkpointBuffer,
 298                                                               &tags);
 299
 300                                 if(tags.chunkId != (dev->checkpointPageSequence + 1) ||
 301                                    tags.sequenceNumber != YAFFS_SEQUENCE_CHECKPOINT_DATA)
 302                                    ok = 0;
 303
 304                                 dev->checkpointByteOffset = 0;
 305                                 dev->checkpointPageSequence++;
 306                                 dev->checkpointCurrentChunk++;
 307
 308                                 if(dev->checkpointCurrentChunk >= dev->nChunksPerBlock)
 309                                         dev->checkpointCurrentBlock = -1;
 310                         }
 311                 }
 312
 313                 if(ok){
 314                         *dataBytes = dev->checkpointBuffer[dev->checkpointByteOffset];
 315                         dev->checkpointByteOffset++;
 316                         i++;
 317                         dataBytes++;
 318                         dev->checkpointByteCount++;
 319                 }
 320         }
 321
 322         return  i;
 323 }
 324
 325 int yaffs_CheckpointClose(yaffs_Device *dev)
 326 {
 327
 328         if(dev->checkpointOpenForWrite){
 329                 if(dev->checkpointByteOffset != 0)
 330                         yaffs_CheckpointFlushBuffer(dev);
 331         } else {
 332                 int i;
 333                 for(i = 0; i < dev->blocksInCheckpoint && dev->checkpointBlockList[i] >= 0; i++){
 334                         yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev,dev->checkpointBlockList[i]);
 335                         if(bi->blockState == YAFFS_BLOCK_STATE_EMPTY)
 336                                 bi->blockState = YAFFS_BLOCK_STATE_CHECKPOINT;
 337                         else {
 338                                 // Todo this looks odd...
 339                         }
 340                 }
 341                 YFREE(dev->checkpointBlockList);
 342                 dev->checkpointBlockList = NULL;
 343         }
 344
 345         dev->nFreeChunks -= dev->blocksInCheckpoint * dev->nChunksPerBlock;
 346         dev->nErasedBlocks -= dev->blocksInCheckpoint;
 347
 348
 349         T(YAFFS_TRACE_CHECKPOINT,(TSTR("checkpoint byte count %d" TENDSTR),
 350                         dev->checkpointByteCount));
 351
 352         if(dev->checkpointBuffer){
 353                 /* free the buffer */
 354                 YFREE(dev->checkpointBuffer);
 355                 dev->checkpointBuffer = NULL;
 356                 return 1;
 357         }
 358         else
 359                 return 0;
 360
 361 }
 362
 363 int yaffs_CheckpointInvalidateStream(yaffs_Device *dev)
 364 {
 365         /* Erase the first checksum block */
 366
 367         T(YAFFS_TRACE_CHECKPOINT,(TSTR("checkpoint invalidate"TENDSTR)));
 368
 369         if(!yaffs_CheckpointSpaceOk(dev))
 370                 return 0;
 371
 372         return yaffs_CheckpointErase(dev);
 373 }
 374
 375
 376