1
2
3
4
5
6
7
8
9
10
11
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 )) {
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
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
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
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
176 dev->checkpt_byte_offs = dev->data_bytes_per_chunk;
177
178
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;
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
224
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
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
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
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
