2 * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
4 * Copyright (C) 2002-2011 Aleph One Ltd.
5 * for Toby Churchill Ltd and Brightstar Engineering
7 * Created by Charles Manning <charles@aleph1.co.uk>
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.
14 /* Summaries write the useful part of the tags for the chunks in a block into an
15 * an array which is written to the last n chunks of the block.
16 * Reading the summaries gives all the tags for the block in one read. Much
19 * Chunks holding summaries are marked with tags making it look like
20 * they are part of a fake file.
22 * The summary could also be used during gc.
26 #include "yaffs_summary.h"
27 #include "yaffs_packedtags2.h"
28 #include "yaffs_nand.h"
29 #include "yaffs_getblockinfo.h"
30 #include "yaffs_bitmap.h"
32 #define YAFFS_SUMMARY_VERSION 1
35 * The summary is built up in an array of summary tags.
36 * This gets written to the last one or two (maybe more) chunks in a block.
37 * A summary header is written as the first part of each chunk of summary data.
38 * The summary header must match or the summary is rejected.
41 /* Summary tags don't need the sequence number because that is redundant. */
42 struct yaffs_summary_tags {
49 struct yaffs_summary_header {
50 unsigned version; /* Must match current version */
51 unsigned block; /* Must be this block */
52 unsigned seq; /* Must be this sequence number */
53 unsigned sum; /* Just add up all the bytes in the tags */
57 static void yaffs_summary_clear(struct yaffs_dev *dev)
61 memset(dev->sum_tags, 0, dev->chunks_per_summary *
62 sizeof(struct yaffs_summary_tags));
66 void yaffs_summary_deinit(struct yaffs_dev *dev)
70 kfree(dev->gc_sum_tags);
71 dev->gc_sum_tags = NULL;
72 dev->chunks_per_summary = 0;
75 int yaffs_summary_init(struct yaffs_dev *dev)
78 int chunks_used; /* Number of chunks used by summary */
81 sum_bytes = dev->param.chunks_per_block *
82 sizeof(struct yaffs_summary_tags);
84 chunks_used = (sum_bytes + dev->data_bytes_per_chunk - 1)/
85 (dev->data_bytes_per_chunk -
86 sizeof(struct yaffs_summary_header));
88 dev->chunks_per_summary = dev->param.chunks_per_block - chunks_used;
89 sum_tags_bytes = sizeof(struct yaffs_summary_tags) *
90 dev->chunks_per_summary;
91 dev->sum_tags = kmalloc(sum_tags_bytes, GFP_NOFS);
92 dev->gc_sum_tags = kmalloc(sum_tags_bytes, GFP_NOFS);
93 if(!dev->sum_tags || !dev->gc_sum_tags) {
94 yaffs_summary_deinit(dev);
98 yaffs_summary_clear(dev);
103 static unsigned yaffs_summary_sum(struct yaffs_dev *dev)
105 u8 *sum_buffer = (u8 *)dev->sum_tags;
109 i = sizeof(struct yaffs_summary_tags) *
110 dev->chunks_per_summary;;
120 static int yaffs_summary_write(struct yaffs_dev *dev, int blk)
122 struct yaffs_ext_tags tags;
124 u8 *sum_buffer = (u8 *)dev->sum_tags;
130 struct yaffs_summary_header hdr;
131 int sum_bytes_per_chunk = dev->data_bytes_per_chunk - sizeof(hdr);
132 struct yaffs_block_info *bi = yaffs_get_block_info(dev, blk);
134 buffer = yaffs_get_temp_buffer(dev);
135 n_bytes = sizeof(struct yaffs_summary_tags) *
136 dev->chunks_per_summary;
137 memset(&tags, 0, sizeof(struct yaffs_ext_tags));
138 tags.obj_id = YAFFS_OBJECTID_SUMMARY;
140 chunk_in_block = dev->chunks_per_summary;
141 chunk_in_nand = dev->alloc_block * dev->param.chunks_per_block +
142 dev-> chunks_per_summary;
143 hdr.version = YAFFS_SUMMARY_VERSION;
145 hdr.seq = bi->seq_number;
146 hdr.sum = yaffs_summary_sum(dev);
150 if (this_tx > sum_bytes_per_chunk)
151 this_tx = sum_bytes_per_chunk;
152 memcpy(buffer, &hdr, sizeof(hdr));
153 memcpy(buffer + sizeof(hdr), sum_buffer, this_tx);
154 tags.n_bytes = this_tx + sizeof(hdr);
155 result = yaffs_wr_chunk_tags_nand(dev, chunk_in_nand,
158 if (result != YAFFS_OK)
160 yaffs_set_chunk_bit(dev, blk, chunk_in_block);
162 dev->n_free_chunks--;
165 sum_buffer += this_tx;
169 } while (result == YAFFS_OK && n_bytes > 0);
170 yaffs_release_temp_buffer(dev, buffer);
173 if (result == YAFFS_OK)
180 int yaffs_summary_read(struct yaffs_dev *dev,
181 struct yaffs_summary_tags *st,
184 struct yaffs_ext_tags tags;
186 u8 *sum_buffer = (u8 *)st;
193 struct yaffs_summary_header hdr;
194 struct yaffs_block_info *bi = yaffs_get_block_info(dev, blk);
195 int sum_bytes_per_chunk = dev->data_bytes_per_chunk - sizeof(hdr);
198 sum_tags_bytes = sizeof(struct yaffs_summary_tags) *
199 dev->chunks_per_summary;
200 buffer = yaffs_get_temp_buffer(dev);
201 n_bytes = sizeof(struct yaffs_summary_tags) * dev->chunks_per_summary;
202 chunk_in_block = dev->chunks_per_summary;
203 chunk_in_nand = blk * dev->param.chunks_per_block +
204 dev->chunks_per_summary;
208 if(this_tx > sum_bytes_per_chunk)
209 this_tx = sum_bytes_per_chunk;
210 result = yaffs_rd_chunk_tags_nand(dev, chunk_in_nand,
213 if (tags.chunk_id != chunk_id ||
214 tags.obj_id != YAFFS_OBJECTID_SUMMARY ||
215 tags.chunk_used == 0 ||
216 tags.ecc_result > YAFFS_ECC_RESULT_FIXED ||
217 tags.n_bytes != (this_tx + sizeof(hdr)))
219 if (result != YAFFS_OK)
222 if (st == dev->sum_tags) {
223 /* If we're scanning then update the block info */
224 yaffs_set_chunk_bit(dev, blk, chunk_in_block);
227 memcpy(&hdr, buffer, sizeof(hdr));
228 memcpy(sum_buffer, buffer + sizeof(hdr), this_tx);
230 sum_buffer += this_tx;
234 } while (result == YAFFS_OK && n_bytes > 0);
235 yaffs_release_temp_buffer(dev, buffer);
237 if(result == YAFFS_OK) {
239 if (hdr.version != YAFFS_SUMMARY_VERSION ||
241 hdr.seq != bi->seq_number ||
242 hdr.sum != yaffs_summary_sum(dev))
246 if (st == dev->sum_tags && result == YAFFS_OK)
252 int yaffs_summary_add(struct yaffs_dev *dev,
253 struct yaffs_ext_tags *tags,
256 struct yaffs_packed_tags2_tags_only tags_only;
257 struct yaffs_summary_tags *sum_tags;
258 int block_in_nand = chunk_in_nand / dev->param.chunks_per_block;
259 int chunk_in_block = chunk_in_nand % dev->param.chunks_per_block;
264 if(chunk_in_block >= 0 && chunk_in_block < dev->chunks_per_summary) {
265 yaffs_pack_tags2_tags_only(&tags_only, tags);
266 sum_tags = &dev->sum_tags[chunk_in_block];
267 sum_tags->chunk_id = tags_only.chunk_id;
268 sum_tags->n_bytes = tags_only.n_bytes;
269 sum_tags->obj_id = tags_only.obj_id;
271 if(chunk_in_block == dev->chunks_per_summary - 1) {
272 /* Time to write out the summary */
273 yaffs_summary_write(dev, block_in_nand);
274 yaffs_summary_clear(dev);
275 yaffs_skip_rest_of_block(dev);
281 int yaffs_summary_fetch(struct yaffs_dev *dev,
282 struct yaffs_ext_tags *tags,
285 struct yaffs_packed_tags2_tags_only tags_only;
286 struct yaffs_summary_tags *sum_tags;
287 if(chunk_in_block >= 0 && chunk_in_block < dev->chunks_per_summary) {
288 sum_tags = &dev->sum_tags[chunk_in_block];
289 tags_only.chunk_id = sum_tags->chunk_id;
290 tags_only.n_bytes = sum_tags->n_bytes;
291 tags_only.obj_id = sum_tags->obj_id;
292 yaffs_unpack_tags2_tags_only(tags, &tags_only);
298 void yaffs_summary_gc(struct yaffs_dev *dev, int blk)
300 struct yaffs_block_info *bi = yaffs_get_block_info(dev, blk);
303 if (!bi->has_summary)
306 for (i = dev->chunks_per_summary; i < dev->param.chunks_per_block; i++) {
307 if( yaffs_check_chunk_bit(dev, blk, i)) {
308 yaffs_clear_chunk_bit(dev, blk, i);
310 dev->n_free_chunks++;