yaffs_checkptrw.c

   1 /*
   2  * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
   3  *
   4  * Copyright (C) 2002-2010 Aleph One Ltd.
   5  *   for Toby Churchill Ltd and Brightstar Engineering
   6  *
   7  * Created by Charles Manning <charles@aleph1.co.uk>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License version 2 as
  11  * published by the Free Software Foundation.
  12  */
  13
  14 #include "yaffs_checkptrw.h"
  15 #include "yaffs_getblockinfo.h"
  16
  17 static int yaffs2_checkpt_space_ok(yaffs_dev_t *dev)
  18 {
  19         int blocks_avail = dev->n_erased_blocks - dev->param.n_reserved_blocks;
  20
  21         T(YAFFS_TRACE_CHECKPOINT,
  22                 (TSTR("checkpt blocks available = %d" TENDSTR),
  23                 blocks_avail));
  24
  25         return (blocks_avail <= 0) ? 0 : 1;
  26 }
  27
  28
  29 static int yaffs_checkpt_erase(yaffs_dev_t *dev)
  30 {
  31         int i;
  32
  33         if (!dev->param.erase_fn)
  34                 return 0;
  35         T(YAFFS_TRACE_CHECKPOINT, (TSTR("checking blocks %d to %d"TENDSTR),
  36                 dev->internal_start_block, dev->internal_end_block));
  37
  38         for (i = dev->internal_start_block; i <= dev->internal_end_block; i++) {
  39                 yaffs_block_info_t *bi = yaffs_get_block_info(dev, i);
  40                 if (bi->block_state == YAFFS_BLOCK_STATE_CHECKPOINT) {
  41                         T(YAFFS_TRACE_CHECKPOINT, (TSTR("erasing checkpt block %d"TENDSTR), i));
  42
  43                         dev->n_erasures++;
  44
  45                         if (dev->param.erase_fn(dev, i - dev->block_offset /* realign */)) {
  46                                 bi->block_state = YAFFS_BLOCK_STATE_EMPTY;
  47                                 dev->n_erased_blocks++;
  48                                 dev->n_free_chunks += dev->param.chunks_per_block;
  49                         } else {
  50                                 dev->param.bad_block_fn(dev, i);
  51                                 bi->block_state = YAFFS_BLOCK_STATE_DEAD;
  52                         }
  53                 }
  54         }
  55
  56         dev->blocks_in_checkpt = 0;
  57
  58         return 1;
  59 }
  60
  61
  62 static void yaffs2_checkpt_find_erased_block(yaffs_dev_t *dev)
  63 {
  64         int  i;
  65         int blocks_avail = dev->n_erased_blocks - dev->param.n_reserved_blocks;
  66         T(YAFFS_TRACE_CHECKPOINT,
  67                 (TSTR("allocating checkpt block: erased %d reserved %d avail %d next %d "TENDSTR),
  68                 dev->n_erased_blocks, dev->param.n_reserved_blocks, blocks_avail, dev->checkpt_next_block));
  69
  70         if (dev->checkpt_next_block >= 0 &&
  71                         dev->checkpt_next_block <= dev->internal_end_block &&
  72                         blocks_avail > 0) {
  73
  74                 for (i = dev->checkpt_next_block; i <= dev->internal_end_block; i++) {
  75                         yaffs_block_info_t *bi = yaffs_get_block_info(dev, i);
  76                         if (bi->block_state == YAFFS_BLOCK_STATE_EMPTY) {
  77                                 dev->checkpt_next_block = i + 1;
  78                                 dev->checkpt_cur_block = i;
  79                                 T(YAFFS_TRACE_CHECKPOINT, (TSTR("allocating checkpt block %d"TENDSTR), i));
  80                                 return;
  81                         }
  82                 }
  83         }
  84         T(YAFFS_TRACE_CHECKPOINT, (TSTR("out of checkpt blocks"TENDSTR)));
  85
  86         dev->checkpt_next_block = -1;
  87         dev->checkpt_cur_block = -1;
  88 }
  89
  90 static void yaffs2_checkpt_find_block(yaffs_dev_t *dev)
  91 {
  92         int  i;
  93         yaffs_ext_tags tags;
  94
  95         T(YAFFS_TRACE_CHECKPOINT, (TSTR("find next checkpt block: start:  blocks %d next %d" TENDSTR),
  96                 dev->blocks_in_checkpt, dev->checkpt_next_block));
  97
  98         if (dev->blocks_in_checkpt < dev->checkpt_max_blocks)
  99                 for (i = dev->checkpt_next_block; i <= dev->internal_end_block; i++) {
 100                         int chunk = i * dev->param.chunks_per_block;
 101                         int realigned_chunk = chunk - dev->chunk_offset;
 102
 103                         dev->param.read_chunk_tags_fn(dev, realigned_chunk,
 104                                         NULL, &tags);
 105                         T(YAFFS_TRACE_CHECKPOINT, (TSTR("find next checkpt block: search: block %d oid %d seq %d eccr %d" TENDSTR),
 106                                 i, tags.obj_id, tags.seq_number, tags.ecc_result));
 107
 108                         if (tags.seq_number == YAFFS_SEQUENCE_CHECKPOINT_DATA) {
 109                                 /* Right kind of block */
 110                                 dev->checkpt_next_block = tags.obj_id;
 111                                 dev->checkpt_cur_block = i;
 112                                 dev->checkpt_block_list[dev->blocks_in_checkpt] = i;
 113                                 dev->blocks_in_checkpt++;
 114                                 T(YAFFS_TRACE_CHECKPOINT, (TSTR("found checkpt block %d"TENDSTR), i));
 115                                 return;
 116                         }
 117                 }
 118
 119         T(YAFFS_TRACE_CHECKPOINT, (TSTR("found no more checkpt blocks"TENDSTR)));
 120
 121         dev->checkpt_next_block = -1;
 122         dev->checkpt_cur_block = -1;
 123 }
 124
 125
 126 int yaffs2_checkpt_open(yaffs_dev_t *dev, int writing)
 127 {
 128
 129
 130         dev->checkpt_open_write = writing;
 131
 132         /* Got the functions we need? */
 133         if (!dev->param.write_chunk_tags_fn ||
 134                 !dev->param.read_chunk_tags_fn ||
 135                 !dev->param.erase_fn ||
 136                 !dev->param.bad_block_fn)
 137                 return 0;
 138
 139         if (writing && !yaffs2_checkpt_space_ok(dev))
 140                 return 0;
 141
 142         if (!dev->checkpt_buffer)
 143                 dev->checkpt_buffer = YMALLOC_DMA(dev->param.total_bytes_per_chunk);
 144         if (!dev->checkpt_buffer)
 145                 return 0;
 146
 147
 148         dev->checkpt_page_seq = 0;
 149         dev->checkpt_byte_count = 0;
 150         dev->checkpt_sum = 0;
 151         dev->checkpt_xor = 0;
 152         dev->checkpt_cur_block = -1;
 153         dev->checkpt_cur_chunk = -1;
 154         dev->checkpt_next_block = dev->internal_start_block;
 155
 156         /* Erase all the blocks in the checkpoint area */
 157         if (writing) {
 158                 memset(dev->checkpt_buffer, 0, dev->data_bytes_per_chunk);
 159                 dev->checkpt_byte_offs = 0;
 160                 return yaffs_checkpt_erase(dev);
 161         } else {
 162                 int i;
 163                 /* Set to a value that will kick off a read */
 164                 dev->checkpt_byte_offs = dev->data_bytes_per_chunk;
 165                 /* A checkpoint block list of 1 checkpoint block per 16 block is (hopefully)
 166                  * going to be way more than we need */
 167                 dev->blocks_in_checkpt = 0;
 168                 dev->checkpt_max_blocks = (dev->internal_end_block - dev->internal_start_block)/16 + 2;
 169                 dev->checkpt_block_list = YMALLOC(sizeof(int) * dev->checkpt_max_blocks);
 170                 if(!dev->checkpt_block_list)
 171                         return 0;
 172
 173                 for (i = 0; i < dev->checkpt_max_blocks; i++)
 174                         dev->checkpt_block_list[i] = -1;
 175         }
 176
 177         return 1;
 178 }
 179
 180 int yaffs2_get_checkpt_sum(yaffs_dev_t *dev, __u32 *sum)
 181 {
 182         __u32 composite_sum;
 183         composite_sum =  (dev->checkpt_sum << 8) | (dev->checkpt_xor & 0xFF);
 184         *sum = composite_sum;
 185         return 1;
 186 }
 187
 188 static int yaffs2_checkpt_flush_buffer(yaffs_dev_t *dev)
 189 {
 190         int chunk;
 191         int realigned_chunk;
 192
 193         yaffs_ext_tags tags;
 194
 195         if (dev->checkpt_cur_block < 0) {
 196                 yaffs2_checkpt_find_erased_block(dev);
 197                 dev->checkpt_cur_chunk = 0;
 198         }
 199
 200         if (dev->checkpt_cur_block < 0)
 201                 return 0;
 202
 203         tags.is_deleted = 0;
 204         tags.obj_id = dev->checkpt_next_block; /* Hint to next place to look */
 205         tags.chunk_id = dev->checkpt_page_seq + 1;
 206         tags.seq_number =  YAFFS_SEQUENCE_CHECKPOINT_DATA;
 207         tags.n_bytes = dev->data_bytes_per_chunk;
 208         if (dev->checkpt_cur_chunk == 0) {
 209                 /* First chunk we write for the block? Set block state to
 210                    checkpoint */
 211                 yaffs_block_info_t *bi = yaffs_get_block_info(dev, dev->checkpt_cur_block);
 212                 bi->block_state = YAFFS_BLOCK_STATE_CHECKPOINT;
 213                 dev->blocks_in_checkpt++;
 214         }
 215
 216         chunk = dev->checkpt_cur_block * dev->param.chunks_per_block + dev->checkpt_cur_chunk;
 217
 218
 219         T(YAFFS_TRACE_CHECKPOINT, (TSTR("checkpoint wite buffer nand %d(%d:%d) objid %d chId %d" TENDSTR),
 220                 chunk, dev->checkpt_cur_block, dev->checkpt_cur_chunk, tags.obj_id, tags.chunk_id));
 221
 222         realigned_chunk = chunk - dev->chunk_offset;
 223
 224         dev->n_page_writes++;
 225
 226         dev->param.write_chunk_tags_fn(dev, realigned_chunk,
 227                         dev->checkpt_buffer, &tags);
 228         dev->checkpt_byte_offs = 0;
 229         dev->checkpt_page_seq++;
 230         dev->checkpt_cur_chunk++;
 231         if (dev->checkpt_cur_chunk >= dev->param.chunks_per_block) {
 232                 dev->checkpt_cur_chunk = 0;
 233                 dev->checkpt_cur_block = -1;
 234         }
 235         memset(dev->checkpt_buffer, 0, dev->data_bytes_per_chunk);
 236
 237         return 1;
 238 }
 239
 240
 241 int yaffs2_checkpt_wr(yaffs_dev_t *dev, const void *data, int n_bytes)
 242 {
 243         int i = 0;
 244         int ok = 1;
 245
 246
 247         __u8 * data_bytes = (__u8 *)data;
 248
 249
 250
 251         if (!dev->checkpt_buffer)
 252                 return 0;
 253
 254         if (!dev->checkpt_open_write)
 255                 return -1;
 256
 257         while (i < n_bytes && ok) {
 258                 dev->checkpt_buffer[dev->checkpt_byte_offs] = *data_bytes;
 259                 dev->checkpt_sum += *data_bytes;
 260                 dev->checkpt_xor ^= *data_bytes;
 261
 262                 dev->checkpt_byte_offs++;
 263                 i++;
 264                 data_bytes++;
 265                 dev->checkpt_byte_count++;
 266
 267
 268                 if (dev->checkpt_byte_offs < 0 ||
 269                    dev->checkpt_byte_offs >= dev->data_bytes_per_chunk)
 270                         ok = yaffs2_checkpt_flush_buffer(dev);
 271         }
 272
 273         return i;
 274 }
 275
 276 int yaffs2_checkpt_rd(yaffs_dev_t *dev, void *data, int n_bytes)
 277 {
 278         int i = 0;
 279         int ok = 1;
 280         yaffs_ext_tags tags;
 281
 282
 283         int chunk;
 284         int realigned_chunk;
 285
 286         __u8 *data_bytes = (__u8 *)data;
 287
 288         if (!dev->checkpt_buffer)
 289                 return 0;
 290
 291         if (dev->checkpt_open_write)
 292                 return -1;
 293
 294         while (i < n_bytes && ok) {
 295
 296
 297                 if (dev->checkpt_byte_offs < 0 ||
 298                         dev->checkpt_byte_offs >= dev->data_bytes_per_chunk) {
 299
 300                         if (dev->checkpt_cur_block < 0) {
 301                                 yaffs2_checkpt_find_block(dev);
 302                                 dev->checkpt_cur_chunk = 0;
 303                         }
 304
 305                         if (dev->checkpt_cur_block < 0)
 306                                 ok = 0;
 307                         else {
 308                                 chunk = dev->checkpt_cur_block *
 309                                         dev->param.chunks_per_block +
 310                                         dev->checkpt_cur_chunk;
 311
 312                                 realigned_chunk = chunk - dev->chunk_offset;
 313
 314                                 dev->n_page_reads++;
 315
 316                                 /* read in the next chunk */
 317                                 dev->param.read_chunk_tags_fn(dev,
 318                                                 realigned_chunk,
 319                                                 dev->checkpt_buffer,
 320                                                 &tags);
 321
 322                                 if (tags.chunk_id != (dev->checkpt_page_seq + 1) ||
 323                                         tags.ecc_result > YAFFS_ECC_RESULT_FIXED ||
 324                                         tags.seq_number != YAFFS_SEQUENCE_CHECKPOINT_DATA)
 325                                         ok = 0;
 326
 327                                 dev->checkpt_byte_offs = 0;
 328                                 dev->checkpt_page_seq++;
 329                                 dev->checkpt_cur_chunk++;
 330
 331                                 if (dev->checkpt_cur_chunk >= dev->param.chunks_per_block)
 332                                         dev->checkpt_cur_block = -1;
 333                         }
 334                 }
 335
 336                 if (ok) {
 337                         *data_bytes = dev->checkpt_buffer[dev->checkpt_byte_offs];
 338                         dev->checkpt_sum += *data_bytes;
 339                         dev->checkpt_xor ^= *data_bytes;
 340                         dev->checkpt_byte_offs++;
 341                         i++;
 342                         data_bytes++;
 343                         dev->checkpt_byte_count++;
 344                 }
 345         }
 346
 347         return  i;
 348 }
 349
 350 int yaffs_checkpt_close(yaffs_dev_t *dev)
 351 {
 352
 353         if (dev->checkpt_open_write) {
 354                 if (dev->checkpt_byte_offs != 0)
 355                         yaffs2_checkpt_flush_buffer(dev);
 356         } else if(dev->checkpt_block_list){
 357                 int i;
 358                 for (i = 0; i < dev->blocks_in_checkpt && dev->checkpt_block_list[i] >= 0; i++) {
 359                         int blk = dev->checkpt_block_list[i];
 360                         yaffs_block_info_t *bi = NULL;
 361                         if( dev->internal_start_block <= blk && blk <= dev->internal_end_block)
 362                                 bi = yaffs_get_block_info(dev, blk);
 363                         if (bi && bi->block_state == YAFFS_BLOCK_STATE_EMPTY)
 364                                 bi->block_state = YAFFS_BLOCK_STATE_CHECKPOINT;
 365                         else {
 366                                 /* Todo this looks odd... */
 367                         }
 368                 }
 369                 YFREE(dev->checkpt_block_list);
 370                 dev->checkpt_block_list = NULL;
 371         }
 372
 373         dev->n_free_chunks -= dev->blocks_in_checkpt * dev->param.chunks_per_block;
 374         dev->n_erased_blocks -= dev->blocks_in_checkpt;
 375
 376
 377         T(YAFFS_TRACE_CHECKPOINT, (TSTR("checkpoint byte count %d" TENDSTR),
 378                         dev->checkpt_byte_count));
 379
 380         if (dev->checkpt_buffer) {
 381                 /* free the buffer */
 382                 YFREE(dev->checkpt_buffer);
 383                 dev->checkpt_buffer = NULL;
 384                 return 1;
 385         } else
 386                 return 0;
 387 }
 388
 389 int yaffs2_checkpt_invalidate_stream(yaffs_dev_t *dev)
 390 {
 391         /* Erase the checkpoint data */
 392
 393         T(YAFFS_TRACE_CHECKPOINT, (TSTR("checkpoint invalidate of %d blocks"TENDSTR),
 394                 dev->blocks_in_checkpt));
 395
 396         return yaffs_checkpt_erase(dev);
 397 }
 398
 399
 400