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