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 18static 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 28static 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 65static 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 98static 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 139int 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 194int 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 203static 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 258int 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 288int 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 359int 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 400int 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} 410