fs/yaffs2/yaffs_checkptrw.c

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