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
yaffs2_checkpt_space_ok(struct yaffs_dev * dev)17 static int yaffs2_checkpt_space_ok(struct yaffs_dev *dev)
18 {
19 int blocks_avail = dev->n_erased_blocks - dev->param.n_reserved_blocks;
20
21 yaffs_trace(YAFFS_TRACE_CHECKPOINT,
22 "checkpt blocks_avail = %d", blocks_avail);
23
24 return (blocks_avail <= 0) ? 0 : 1;
25 }
26
yaffs_checkpt_erase(struct yaffs_dev * dev)27 static int yaffs_checkpt_erase(struct yaffs_dev *dev)
28 {
29 int i;
30
31 if (!dev->param.erase_fn)
32 return 0;
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;
55 }
56 }
57 }
58
59 dev->blocks_in_checkpt = 0;
60
61 return 1;
62 }
63
yaffs2_checkpt_find_erased_block(struct yaffs_dev * dev)64 static void yaffs2_checkpt_find_erased_block(struct yaffs_dev *dev)
65 {
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);
87 return;
88 }
89 }
90 }
91 yaffs_trace(YAFFS_TRACE_CHECKPOINT, "out of checkpt blocks");
92
93 dev->checkpt_next_block = -1;
94 dev->checkpt_cur_block = -1;
95 }
96
yaffs2_checkpt_find_block(struct yaffs_dev * dev)97 static void yaffs2_checkpt_find_block(struct yaffs_dev *dev)
98 {
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) {
120 /* Right kind of block */
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);
128 return;
129 }
130 }
131
132 yaffs_trace(YAFFS_TRACE_CHECKPOINT, "found no more checkpt blocks");
133
134 dev->checkpt_next_block = -1;
135 dev->checkpt_cur_block = -1;
136 }
137
yaffs2_checkpt_open(struct yaffs_dev * dev,int writing)138 int yaffs2_checkpt_open(struct yaffs_dev *dev, int writing)
139 {
140 int i;
141
142 dev->checkpt_open_write = writing;
143
144 /* Got the functions we need? */
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)
148 return 0;
149
150 if (writing && !yaffs2_checkpt_space_ok(dev))
151 return 0;
152
153 if (!dev->checkpt_buffer)
154 dev->checkpt_buffer =
155 kmalloc(dev->param.total_bytes_per_chunk, GFP_NOFS);
156 if (!dev->checkpt_buffer)
157 return 0;
158
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;
166
167 /* Erase all the blocks in the checkpoint area */
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 }
173
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;
186
187 for (i = 0; i < dev->checkpt_max_blocks; i++)
188 dev->checkpt_block_list[i] = -1;
189
190 return 1;
191 }
192
yaffs2_get_checkpt_sum(struct yaffs_dev * dev,u32 * sum)193 int yaffs2_get_checkpt_sum(struct yaffs_dev *dev, u32 * sum)
194 {
195 u32 composite_sum;
196
197 composite_sum = (dev->checkpt_sum << 8) | (dev->checkpt_xor & 0xff);
198 *sum = composite_sum;
199 return 1;
200 }
201
yaffs2_checkpt_flush_buffer(struct yaffs_dev * dev)202 static int yaffs2_checkpt_flush_buffer(struct yaffs_dev *dev)
203 {
204 int chunk;
205 int realigned_chunk;
206 struct yaffs_ext_tags tags;
207
208 if (dev->checkpt_cur_block < 0) {
209 yaffs2_checkpt_find_erased_block(dev);
210 dev->checkpt_cur_chunk = 0;
211 }
212
213 if (dev->checkpt_cur_block < 0)
214 return 0;
215
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) {
222 /* First chunk we write for the block? Set block state to
223 checkpoint */
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++;
228 }
229
230 chunk =
231 dev->checkpt_cur_block * dev->param.chunks_per_block +
232 dev->checkpt_cur_chunk;
233
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);
238
239 realigned_chunk = chunk - dev->chunk_offset;
240
241 dev->n_page_writes++;
242
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;
251 }
252 memset(dev->checkpt_buffer, 0, dev->data_bytes_per_chunk);
253
254 return 1;
255 }
256
yaffs2_checkpt_wr(struct yaffs_dev * dev,const void * data,int n_bytes)257 int yaffs2_checkpt_wr(struct yaffs_dev *dev, const void *data, int n_bytes)
258 {
259 int i = 0;
260 int ok = 1;
261 u8 *data_bytes = (u8 *) data;
262
263 if (!dev->checkpt_buffer)
264 return 0;
265
266 if (!dev->checkpt_open_write)
267 return -1;
268
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;
273
274 dev->checkpt_byte_offs++;
275 i++;
276 data_bytes++;
277 dev->checkpt_byte_count++;
278
279 if (dev->checkpt_byte_offs < 0 ||
280 dev->checkpt_byte_offs >= dev->data_bytes_per_chunk)
281 ok = yaffs2_checkpt_flush_buffer(dev);
282 }
283
284 return i;
285 }
286
yaffs2_checkpt_rd(struct yaffs_dev * dev,void * data,int n_bytes)287 int yaffs2_checkpt_rd(struct yaffs_dev *dev, void *data, int n_bytes)
288 {
289 int i = 0;
290 int ok = 1;
291 struct yaffs_ext_tags tags;
292 int chunk;
293 int realigned_chunk;
294 u8 *data_bytes = (u8 *) data;
295
296 if (!dev->checkpt_buffer)
297 return 0;
298
299 if (dev->checkpt_open_write)
300 return -1;
301
302 while (i < n_bytes && ok) {
303
304 if (dev->checkpt_byte_offs < 0 ||
305 dev->checkpt_byte_offs >= dev->data_bytes_per_chunk) {
306
307 if (dev->checkpt_cur_block < 0) {
308 yaffs2_checkpt_find_block(dev);
309 dev->checkpt_cur_chunk = 0;
310 }
311
312 if (dev->checkpt_cur_block < 0) {
313 ok = 0;
314 break;
315 }
316
317 chunk = dev->checkpt_cur_block *
318 dev->param.chunks_per_block +
319 dev->checkpt_cur_chunk;
320
321 realigned_chunk = chunk - dev->chunk_offset;
322 dev->n_page_reads++;
323
324 /* read in the next chunk */
325 dev->param.read_chunk_tags_fn(dev,
326 realigned_chunk,
327 dev->checkpt_buffer,
328 &tags);
329
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 }
336
337 dev->checkpt_byte_offs = 0;
338 dev->checkpt_page_seq++;
339 dev->checkpt_cur_chunk++;
340
341 if (dev->checkpt_cur_chunk >=
342 dev->param.chunks_per_block)
343 dev->checkpt_cur_block = -1;
344 }
345
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++;
353 }
354
355 return i;
356 }
357
yaffs_checkpt_close(struct yaffs_dev * dev)358 int yaffs_checkpt_close(struct yaffs_dev *dev)
359 {
360 int i;
361
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;
377 }
378 kfree(dev->checkpt_block_list);
379 dev->checkpt_block_list = NULL;
380 }
381
382 dev->n_free_chunks -=
383 dev->blocks_in_checkpt * dev->param.chunks_per_block;
384 dev->n_erased_blocks -= dev->blocks_in_checkpt;
385
386 yaffs_trace(YAFFS_TRACE_CHECKPOINT, "checkpoint byte count %d",
387 dev->checkpt_byte_count);
388
389 if (dev->checkpt_buffer) {
390 /* free the buffer */
391 kfree(dev->checkpt_buffer);
392 dev->checkpt_buffer = NULL;
393 return 1;
394 } else {
395 return 0;
396 }
397 }
398
yaffs2_checkpt_invalidate_stream(struct yaffs_dev * dev)399 int yaffs2_checkpt_invalidate_stream(struct yaffs_dev *dev)
400 {
401 /* Erase the checkpoint data */
402
403 yaffs_trace(YAFFS_TRACE_CHECKPOINT,
404 "checkpoint invalidate of %d blocks",
405 dev->blocks_in_checkpt);
406
407 return yaffs_checkpt_erase(dev);
408 }
409