[people/ms/u-boot.git] / fs / yaffs2 / yaffs_summary.c

/*
 * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
 *
 * Copyright (C) 2002-2011 Aleph One Ltd.
 *   for Toby Churchill Ltd and Brightstar Engineering
 *
 * Created by Charles Manning <charles@aleph1.co.uk>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

/* Summaries write the useful part of the tags for the chunks in a block into an
 * an array which is written to the last n chunks of the block.
 * Reading the summaries gives all the tags for the block in one read. Much
 * faster.
 *
 * Chunks holding summaries are marked with tags making it look like
 * they are part of a fake file.
 *
 * The summary could also be used during gc.
 *
 */

#include "yaffs_summary.h"
#include "yaffs_packedtags2.h"
#include "yaffs_nand.h"
#include "yaffs_getblockinfo.h"
#include "yaffs_bitmap.h"

/*
 * The summary is built up in an array of summary tags.
 * This gets written to the last one or two (maybe more) chunks in a block.
 * A summary header is written as the first part of each chunk of summary data.
 * The summary header must match or the summary is rejected.
 */

/* Summary tags don't need the sequence number because that is redundant. */
struct yaffs_summary_tags {
	unsigned obj_id;
	unsigned chunk_id;
	unsigned n_bytes;
};

/* Summary header */
struct yaffs_summary_header {
	unsigned version;	/* Must match current version */
	unsigned block;		/* Must be this block */
	unsigned seq;		/* Must be this sequence number */
	unsigned sum;		/* Just add up all the bytes in the tags */
};


static void yaffs_summary_clear(struct yaffs_dev *dev)
{
	if (!dev->sum_tags)
		return;
	memset(dev->sum_tags, 0, dev->chunks_per_summary *
		sizeof(struct yaffs_summary_tags));
}


void yaffs_summary_deinit(struct yaffs_dev *dev)
{
	kfree(dev->sum_tags);
	dev->sum_tags = NULL;
	kfree(dev->gc_sum_tags);
	dev->gc_sum_tags = NULL;
	dev->chunks_per_summary = 0;
}

int yaffs_summary_init(struct yaffs_dev *dev)
{
	int sum_bytes;
	int chunks_used; /* Number of chunks used by summary */
	int sum_tags_bytes;

	sum_bytes = dev->param.chunks_per_block *
			sizeof(struct yaffs_summary_tags);

	chunks_used = (sum_bytes + dev->data_bytes_per_chunk - 1)/
			(dev->data_bytes_per_chunk -
				sizeof(struct yaffs_summary_header));

	dev->chunks_per_summary = dev->param.chunks_per_block - chunks_used;
	sum_tags_bytes = sizeof(struct yaffs_summary_tags) *
				dev->chunks_per_summary;
	dev->sum_tags = kmalloc(sum_tags_bytes, GFP_NOFS);
	dev->gc_sum_tags = kmalloc(sum_tags_bytes, GFP_NOFS);
	if (!dev->sum_tags || !dev->gc_sum_tags) {
		yaffs_summary_deinit(dev);
		return YAFFS_FAIL;
	}

	yaffs_summary_clear(dev);

	return YAFFS_OK;
}

static unsigned yaffs_summary_sum(struct yaffs_dev *dev)
{
	u8 *sum_buffer = (u8 *)dev->sum_tags;
	int i;
	unsigned sum = 0;

	i = sizeof(struct yaffs_summary_tags) *
				dev->chunks_per_summary;
	while (i > 0) {
		sum += *sum_buffer;
		sum_buffer++;
		i--;
	}

	return sum;
}

static int yaffs_summary_write(struct yaffs_dev *dev, int blk)
{
	struct yaffs_ext_tags tags;
	u8 *buffer;
	u8 *sum_buffer = (u8 *)dev->sum_tags;
	int n_bytes;
	int chunk_in_nand;
	int chunk_in_block;
	int result;
	int this_tx;
	struct yaffs_summary_header hdr;
	int sum_bytes_per_chunk = dev->data_bytes_per_chunk - sizeof(hdr);
	struct yaffs_block_info *bi = yaffs_get_block_info(dev, blk);

	buffer = yaffs_get_temp_buffer(dev);
	n_bytes = sizeof(struct yaffs_summary_tags) *
				dev->chunks_per_summary;
	memset(&tags, 0, sizeof(struct yaffs_ext_tags));
	tags.obj_id = YAFFS_OBJECTID_SUMMARY;
	tags.chunk_id = 1;
	chunk_in_block = dev->chunks_per_summary;
	chunk_in_nand = dev->alloc_block * dev->param.chunks_per_block +
						dev->chunks_per_summary;
	hdr.version = YAFFS_SUMMARY_VERSION;
	hdr.block = blk;
	hdr.seq = bi->seq_number;
	hdr.sum = yaffs_summary_sum(dev);

	do {
		this_tx = n_bytes;
		if (this_tx > sum_bytes_per_chunk)
			this_tx = sum_bytes_per_chunk;
		memcpy(buffer, &hdr, sizeof(hdr));
		memcpy(buffer + sizeof(hdr), sum_buffer, this_tx);
		tags.n_bytes = this_tx + sizeof(hdr);
		result = yaffs_wr_chunk_tags_nand(dev, chunk_in_nand,
						buffer, &tags);

		if (result != YAFFS_OK)
			break;
		yaffs_set_chunk_bit(dev, blk, chunk_in_block);
		bi->pages_in_use++;
		dev->n_free_chunks--;

		n_bytes -= this_tx;
		sum_buffer += this_tx;
		chunk_in_nand++;
		chunk_in_block++;
		tags.chunk_id++;
	} while (result == YAFFS_OK && n_bytes > 0);
	yaffs_release_temp_buffer(dev, buffer);


	if (result == YAFFS_OK)
		bi->has_summary = 1;


	return result;
}

int yaffs_summary_read(struct yaffs_dev *dev,
			struct yaffs_summary_tags *st,
			int blk)
{
	struct yaffs_ext_tags tags;
	u8 *buffer;
	u8 *sum_buffer = (u8 *)st;
	int n_bytes;
	int chunk_id;
	int chunk_in_nand;
	int chunk_in_block;
	int result;
	int this_tx;
	struct yaffs_summary_header hdr;
	struct yaffs_block_info *bi = yaffs_get_block_info(dev, blk);
	int sum_bytes_per_chunk = dev->data_bytes_per_chunk - sizeof(hdr);

	buffer = yaffs_get_temp_buffer(dev);
	n_bytes = sizeof(struct yaffs_summary_tags) * dev->chunks_per_summary;
	chunk_in_block = dev->chunks_per_summary;
	chunk_in_nand = blk * dev->param.chunks_per_block +
							dev->chunks_per_summary;
	chunk_id = 1;
	do {
		this_tx = n_bytes;
		if (this_tx > sum_bytes_per_chunk)
			this_tx = sum_bytes_per_chunk;
		result = yaffs_rd_chunk_tags_nand(dev, chunk_in_nand,
						buffer, &tags);

		if (tags.chunk_id != chunk_id ||
			tags.obj_id != YAFFS_OBJECTID_SUMMARY ||
			tags.chunk_used == 0 ||
			tags.ecc_result > YAFFS_ECC_RESULT_FIXED ||
			tags.n_bytes != (this_tx + sizeof(hdr)))
				result = YAFFS_FAIL;
		if (result != YAFFS_OK)
			break;

		if (st == dev->sum_tags) {
			/* If we're scanning then update the block info */
			yaffs_set_chunk_bit(dev, blk, chunk_in_block);
			bi->pages_in_use++;
		}
		memcpy(&hdr, buffer, sizeof(hdr));
		memcpy(sum_buffer, buffer + sizeof(hdr), this_tx);
		n_bytes -= this_tx;
		sum_buffer += this_tx;
		chunk_in_nand++;
		chunk_in_block++;
		chunk_id++;
	} while (result == YAFFS_OK && n_bytes > 0);
	yaffs_release_temp_buffer(dev, buffer);

	if (result == YAFFS_OK) {
		/* Verify header */
		if (hdr.version != YAFFS_SUMMARY_VERSION ||
		    hdr.seq != bi->seq_number ||
		    hdr.sum != yaffs_summary_sum(dev))
			result = YAFFS_FAIL;
	}

	if (st == dev->sum_tags && result == YAFFS_OK)
		bi->has_summary = 1;

	return result;
}

int yaffs_summary_add(struct yaffs_dev *dev,
			struct yaffs_ext_tags *tags,
			int chunk_in_nand)
{
	struct yaffs_packed_tags2_tags_only tags_only;
	struct yaffs_summary_tags *sum_tags;
	int block_in_nand = chunk_in_nand / dev->param.chunks_per_block;
	int chunk_in_block = chunk_in_nand % dev->param.chunks_per_block;

	if (!dev->sum_tags)
		return YAFFS_OK;

	if (chunk_in_block >= 0 && chunk_in_block < dev->chunks_per_summary) {
		yaffs_pack_tags2_tags_only(&tags_only, tags);
		sum_tags = &dev->sum_tags[chunk_in_block];
		sum_tags->chunk_id = tags_only.chunk_id;
		sum_tags->n_bytes = tags_only.n_bytes;
		sum_tags->obj_id = tags_only.obj_id;

		if (chunk_in_block == dev->chunks_per_summary - 1) {
			/* Time to write out the summary */
			yaffs_summary_write(dev, block_in_nand);
			yaffs_summary_clear(dev);
			yaffs_skip_rest_of_block(dev);
		}
	}
	return YAFFS_OK;
}

int yaffs_summary_fetch(struct yaffs_dev *dev,
			struct yaffs_ext_tags *tags,
			int chunk_in_block)
{
	struct yaffs_packed_tags2_tags_only tags_only;
	struct yaffs_summary_tags *sum_tags;
	if (chunk_in_block >= 0 && chunk_in_block < dev->chunks_per_summary) {
		sum_tags = &dev->sum_tags[chunk_in_block];
		tags_only.chunk_id = sum_tags->chunk_id;
		tags_only.n_bytes = sum_tags->n_bytes;
		tags_only.obj_id = sum_tags->obj_id;
		yaffs_unpack_tags2_tags_only(tags, &tags_only);
		return YAFFS_OK;
	}
	return YAFFS_FAIL;
}

void yaffs_summary_gc(struct yaffs_dev *dev, int blk)
{
	struct yaffs_block_info *bi = yaffs_get_block_info(dev, blk);
	int i;

	if (!bi->has_summary)
		return;

	for (i = dev->chunks_per_summary;
	     i < dev->param.chunks_per_block;
	     i++) {
		if (yaffs_check_chunk_bit(dev, blk, i)) {
			yaffs_clear_chunk_bit(dev, blk, i);
			bi->pages_in_use--;
			dev->n_free_chunks++;
		}
	}
}
Commit	Line	Data
753ac610 CM	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	/* 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
	17	* faster.
	18	*
	19	* Chunks holding summaries are marked with tags making it look like
	20	* they are part of a fake file.
	21	*
	22	* The summary could also be used during gc.
	23	*
	24	*/
	25
	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"
	31
	32	/*
	33	* The summary is built up in an array of summary tags.
	34	* This gets written to the last one or two (maybe more) chunks in a block.
	35	* A summary header is written as the first part of each chunk of summary data.
	36	* The summary header must match or the summary is rejected.
	37	*/
	38
	39	/* Summary tags don't need the sequence number because that is redundant. */
	40	struct yaffs_summary_tags {
	41	unsigned obj_id;
	42	unsigned chunk_id;
	43	unsigned n_bytes;
	44	};
	45
	46	/* Summary header */
	47	struct yaffs_summary_header {
	48	unsigned version; /* Must match current version */
	49	unsigned block; /* Must be this block */
	50	unsigned seq; /* Must be this sequence number */
	51	unsigned sum; /* Just add up all the bytes in the tags */
	52	};
	53
	54
	55	static void yaffs_summary_clear(struct yaffs_dev *dev)
	56	{
	57	if (!dev->sum_tags)
	58	return;
	59	memset(dev->sum_tags, 0, dev->chunks_per_summary *
	60	sizeof(struct yaffs_summary_tags));
	61	}
	62
	63
	64	void yaffs_summary_deinit(struct yaffs_dev *dev)
65	{
66	kfree(dev->sum_tags);
67	dev->sum_tags = NULL;
68	kfree(dev->gc_sum_tags);
69	dev->gc_sum_tags = NULL;
70	dev->chunks_per_summary = 0;
71	}
72
73	int yaffs_summary_init(struct yaffs_dev *dev)
74	{
75	int sum_bytes;
76	int chunks_used; /* Number of chunks used by summary */
77	int sum_tags_bytes;
78
79	sum_bytes = dev->param.chunks_per_block *
80	sizeof(struct yaffs_summary_tags);
81
82	chunks_used = (sum_bytes + dev->data_bytes_per_chunk - 1)/
83	(dev->data_bytes_per_chunk -
84	sizeof(struct yaffs_summary_header));
85
86	dev->chunks_per_summary = dev->param.chunks_per_block - chunks_used;
87	sum_tags_bytes = sizeof(struct yaffs_summary_tags) *
88	dev->chunks_per_summary;
89	dev->sum_tags = kmalloc(sum_tags_bytes, GFP_NOFS);
90	dev->gc_sum_tags = kmalloc(sum_tags_bytes, GFP_NOFS);
91	if (!dev->sum_tags \|\| !dev->gc_sum_tags) {
92	yaffs_summary_deinit(dev);
93	return YAFFS_FAIL;
94	}
95
96	yaffs_summary_clear(dev);
97
98	return YAFFS_OK;
99	}
100
101	static unsigned yaffs_summary_sum(struct yaffs_dev *dev)
102	{
103	u8 sum_buffer = (u8 )dev->sum_tags;
104	int i;
105	unsigned sum = 0;
106
107	i = sizeof(struct yaffs_summary_tags) *
108	dev->chunks_per_summary;
109	while (i > 0) {
110	sum += *sum_buffer;
111	sum_buffer++;
112	i--;
113	}
114
115	return sum;
116	}
117
118	static int yaffs_summary_write(struct yaffs_dev *dev, int blk)
119	{
120	struct yaffs_ext_tags tags;
121	u8 *buffer;
122	u8 sum_buffer = (u8 )dev->sum_tags;
123	int n_bytes;
124	int chunk_in_nand;
125	int chunk_in_block;
126	int result;
127	int this_tx;
128	struct yaffs_summary_header hdr;
129	int sum_bytes_per_chunk = dev->data_bytes_per_chunk - sizeof(hdr);
130	struct yaffs_block_info *bi = yaffs_get_block_info(dev, blk);
131
132	buffer = yaffs_get_temp_buffer(dev);
133	n_bytes = sizeof(struct yaffs_summary_tags) *
134	dev->chunks_per_summary;
135	memset(&tags, 0, sizeof(struct yaffs_ext_tags));
136	tags.obj_id = YAFFS_OBJECTID_SUMMARY;
137	tags.chunk_id = 1;
138	chunk_in_block = dev->chunks_per_summary;
139	chunk_in_nand = dev->alloc_block * dev->param.chunks_per_block +
140	dev->chunks_per_summary;
141	hdr.version = YAFFS_SUMMARY_VERSION;
142	hdr.block = blk;
143	hdr.seq = bi->seq_number;
144	hdr.sum = yaffs_summary_sum(dev);
145
146	do {
147	this_tx = n_bytes;
148	if (this_tx > sum_bytes_per_chunk)
149	this_tx = sum_bytes_per_chunk;
150	memcpy(buffer, &hdr, sizeof(hdr));
151	memcpy(buffer + sizeof(hdr), sum_buffer, this_tx);
152	tags.n_bytes = this_tx + sizeof(hdr);
153	result = yaffs_wr_chunk_tags_nand(dev, chunk_in_nand,
154	buffer, &tags);
155
156	if (result != YAFFS_OK)
157	break;
158	yaffs_set_chunk_bit(dev, blk, chunk_in_block);
159	bi->pages_in_use++;
160	dev->n_free_chunks--;
161
162	n_bytes -= this_tx;
163	sum_buffer += this_tx;
164	chunk_in_nand++;
165	chunk_in_block++;
166	tags.chunk_id++;
167	} while (result == YAFFS_OK && n_bytes > 0);
168	yaffs_release_temp_buffer(dev, buffer);
169
170
171	if (result == YAFFS_OK)
172	bi->has_summary = 1;
173
174
175	return result;
176	}
177
178	int yaffs_summary_read(struct yaffs_dev *dev,
179	struct yaffs_summary_tags *st,
180	int blk)
181	{
182	struct yaffs_ext_tags tags;
183	u8 *buffer;
184	u8 sum_buffer = (u8 )st;
185	int n_bytes;
186	int chunk_id;
187	int chunk_in_nand;
188	int chunk_in_block;
189	int result;
190	int this_tx;
191	struct yaffs_summary_header hdr;
192	struct yaffs_block_info *bi = yaffs_get_block_info(dev, blk);
193	int sum_bytes_per_chunk = dev->data_bytes_per_chunk - sizeof(hdr);
753ac610	194
753ac610 CM	195	buffer = yaffs_get_temp_buffer(dev);
	196	n_bytes = sizeof(struct yaffs_summary_tags) * dev->chunks_per_summary;
	197	chunk_in_block = dev->chunks_per_summary;
	198	chunk_in_nand = blk * dev->param.chunks_per_block +
	199	dev->chunks_per_summary;
	200	chunk_id = 1;
	201	do {
	202	this_tx = n_bytes;
	203	if (this_tx > sum_bytes_per_chunk)
	204	this_tx = sum_bytes_per_chunk;
	205	result = yaffs_rd_chunk_tags_nand(dev, chunk_in_nand,
	206	buffer, &tags);
	207
	208	if (tags.chunk_id != chunk_id \|\|
	209	tags.obj_id != YAFFS_OBJECTID_SUMMARY \|\|
	210	tags.chunk_used == 0 \|\|
	211	tags.ecc_result > YAFFS_ECC_RESULT_FIXED \|\|
	212	tags.n_bytes != (this_tx + sizeof(hdr)))
	213	result = YAFFS_FAIL;
	214	if (result != YAFFS_OK)
	215	break;
	216
	217	if (st == dev->sum_tags) {
	218	/* If we're scanning then update the block info */
	219	yaffs_set_chunk_bit(dev, blk, chunk_in_block);
	220	bi->pages_in_use++;
	221	}
	222	memcpy(&hdr, buffer, sizeof(hdr));
	223	memcpy(sum_buffer, buffer + sizeof(hdr), this_tx);
	224	n_bytes -= this_tx;
	225	sum_buffer += this_tx;
	226	chunk_in_nand++;
	227	chunk_in_block++;
	228	chunk_id++;
	229	} while (result == YAFFS_OK && n_bytes > 0);
	230	yaffs_release_temp_buffer(dev, buffer);
	231
	232	if (result == YAFFS_OK) {
	233	/* Verify header */
	234	if (hdr.version != YAFFS_SUMMARY_VERSION \|\|
753ac610 CM	235	hdr.seq != bi->seq_number \|\|
	236	hdr.sum != yaffs_summary_sum(dev))
	237	result = YAFFS_FAIL;
	238	}
	239
	240	if (st == dev->sum_tags && result == YAFFS_OK)
	241	bi->has_summary = 1;
	242
	243	return result;
	244	}
	245
	246	int yaffs_summary_add(struct yaffs_dev *dev,
	247	struct yaffs_ext_tags *tags,
	248	int chunk_in_nand)
	249	{
	250	struct yaffs_packed_tags2_tags_only tags_only;
	251	struct yaffs_summary_tags *sum_tags;
	252	int block_in_nand = chunk_in_nand / dev->param.chunks_per_block;
	253	int chunk_in_block = chunk_in_nand % dev->param.chunks_per_block;
	254
	255	if (!dev->sum_tags)
	256	return YAFFS_OK;
	257
	258	if (chunk_in_block >= 0 && chunk_in_block < dev->chunks_per_summary) {
	259	yaffs_pack_tags2_tags_only(&tags_only, tags);
	260	sum_tags = &dev->sum_tags[chunk_in_block];
	261	sum_tags->chunk_id = tags_only.chunk_id;
	262	sum_tags->n_bytes = tags_only.n_bytes;
	263	sum_tags->obj_id = tags_only.obj_id;
	264
	265	if (chunk_in_block == dev->chunks_per_summary - 1) {
	266	/* Time to write out the summary */
	267	yaffs_summary_write(dev, block_in_nand);
	268	yaffs_summary_clear(dev);
	269	yaffs_skip_rest_of_block(dev);
	270	}
	271	}
	272	return YAFFS_OK;
	273	}
	274
	275	int yaffs_summary_fetch(struct yaffs_dev *dev,
	276	struct yaffs_ext_tags *tags,
	277	int chunk_in_block)
	278	{
	279	struct yaffs_packed_tags2_tags_only tags_only;
	280	struct yaffs_summary_tags *sum_tags;
	281	if (chunk_in_block >= 0 && chunk_in_block < dev->chunks_per_summary) {
	282	sum_tags = &dev->sum_tags[chunk_in_block];
	283	tags_only.chunk_id = sum_tags->chunk_id;
	284	tags_only.n_bytes = sum_tags->n_bytes;
	285	tags_only.obj_id = sum_tags->obj_id;
	286	yaffs_unpack_tags2_tags_only(tags, &tags_only);
	287	return YAFFS_OK;
	288	}
	289	return YAFFS_FAIL;
	290	}
	291
	292	void yaffs_summary_gc(struct yaffs_dev *dev, int blk)
	293	{
	294	struct yaffs_block_info *bi = yaffs_get_block_info(dev, blk);
	295	int i;
	296
	297	if (!bi->has_summary)
	298	return;
299
300	for (i = dev->chunks_per_summary;
301	i < dev->param.chunks_per_block;
302	i++) {
303	if (yaffs_check_chunk_bit(dev, blk, i)) {
304	yaffs_clear_chunk_bit(dev, blk, i);
305	bi->pages_in_use--;
306	dev->n_free_chunks++;
307	}
308	}
309	}