yaffs2-objs += yaffs_yaffs1.o
yaffs2-objs += yaffs_yaffs2.o
yaffs2-objs += yaffs_verify.o
+ yaffs2-objs += yaffs_summary.o
yaffs2multi-objs := yaffs_mtdif.o yaffs_mtdif2_multi.o
yaffs2multi-objs += yaffs_mtdif1_multi.o yaffs_packedtags1.o
yaffs2multi-objs += yaffs_yaffs1.o
yaffs2multi-objs += yaffs_yaffs2.o
yaffs2multi-objs += yaffs_verify.o
+ yaffs2multi-objs += yaffs_summary.o
else
KERNELDIR ?= /lib/modules/$(shell uname -r)/build
yaffs_bitmap.o \
yaffs_yaffs1.o \
yaffs_yaffs2.o \
- yaffs_verify.o
+ yaffs_verify.o \
+ yaffs_summary.o
# yaffs_checkptrwtest.o\
yaffs_yaffs1.c yaffs_yaffs1.h \
yaffs_yaffs2.c yaffs_yaffs2.h \
yaffs_bitmap.c yaffs_bitmap.h \
- yaffs_verify.c yaffs_verify.h
+ yaffs_verify.c yaffs_verify.h \
+ yaffs_summary.c yaffs_summary.h
YAFFSDIRECTSYMLINKS = yaffsfs.c yaffs_flashif.h yaffs_flashif2.h\
yaffsfs.h yaffs_osglue.h ydirectenv.h \
//null_name_test("yaffs2");
test_flash_traffic("yaffs2");
- link_follow_test("/yaffs2");
+ // link_follow_test("/yaffs2");
return 0;
yaffs_bitmap.o \
yaffs_yaffs1.o \
yaffs_yaffs2.o \
- yaffs_verify.o
+ yaffs_verify.o \
+ yaffs_summary.o
# yaffs_checkptrwtest.o\
yaffs_yaffs1.c yaffs_yaffs1.h \
yaffs_yaffs2.c yaffs_yaffs2.h \
yaffs_bitmap.c yaffs_bitmap.h \
- yaffs_verify.c yaffs_verify.h
+ yaffs_verify.c yaffs_verify.h \
+ yaffs_summary.c yaffs_summary.h
YAFFSDIRECTSYMLINKS = yaffsfs.c yaffs_flashif.h yaffs_flashif2.h\
yaffsfs.h yaffs_osglue.h ydirectenv.h \
#include "yaffs_nameval.h"
#include "yaffs_allocator.h"
#include "yaffs_attribs.h"
+#include "yaffs_summary.h"
/* Note YAFFS_GC_GOOD_ENOUGH must be <= YAFFS_GC_PASSIVE_THRESHOLD */
#define YAFFS_GC_GOOD_ENOUGH 2
bi->has_shrink_hdr = 0;
bi->skip_erased_check = 1; /* Clean, so no need to check */
bi->gc_prioritise = 0;
+ bi->has_summary=0;
+
yaffs_clear_chunk_bits(dev, block_no);
yaffs_trace(YAFFS_TRACE_ERASE, "Erased block %d", block_no);
dev->gc_disable = 1;
+ yaffs_summary_gc(dev, block);
+
if (is_checkpt_block || !yaffs_still_some_chunks(dev, block)) {
yaffs_trace(YAFFS_TRACE_TRACING,
"Collecting block %d that has no chunks in use",
if (!init_failed && !yaffs_create_initial_dir(dev))
init_failed = 1;
+ if(!init_failed && dev->param.is_yaffs2 &&
+ !dev->param.disable_summary &&
+ !yaffs_summary_init(dev))
+ init_failed = 1;
+
if (!init_failed) {
/* Now scan the flash. */
if (dev->param.is_yaffs2) {
yaffs_deinit_blocks(dev);
yaffs_deinit_tnodes_and_objs(dev);
+ yaffs_summary_deinit(dev);
+
if (dev->param.n_caches > 0 && dev->cache) {
for (i = 0; i < dev->param.n_caches; i++) {
#define YAFFS_OBJECTID_UNLINKED 3
#define YAFFS_OBJECTID_DELETED 4
+/* Fake object Id for summary data */
+#define YAFFS_OBJECTID_SUMMARY 0x10
+
/* Pseudo object ids for checkpointing */
-#define YAFFS_OBJECTID_SB_HEADER 0x10
#define YAFFS_OBJECTID_CHECKPOINT_DATA 0x20
-#define YAFFS_SEQUENCE_CHECKPOINT_DATA 0x21
+#define YAFFS_SEQUENCE_CHECKPOINT_DATA 0x21
#define YAFFS_MAX_SHORT_OP_CACHES 20
Block should be prioritised for GC */
u32 chunk_error_strikes:3; /* How many times we've had ecc etc
failures on this block and tried to reuse it */
+ u32 has_summary:1; /* The block has a summary */
u32 has_shrink_hdr:1; /* This block has at least one shrink header */
u32 seq_number; /* block sequence number for yaffs2 */
int auto_unicode;
#endif
int always_check_erased; /* Force chunk erased check always on */
+
+ int disable_summary;
};
struct yaffs_dev {
unsigned gc_block;
unsigned gc_chunk;
unsigned gc_skip;
+ struct yaffs_summary_tags *gc_sum_tags;
/* Special directories */
struct yaffs_obj *root_dir;
/* Dirty directory handling */
struct list_head dirty_dirs; /* List of dirty directories */
- /* Statistcs */
+ /* Summary */
+ int chunks_per_summary;
+ struct yaffs_summary_tags *sum_tags;
+
+ /* Statistics */
u32 n_page_writes;
u32 n_page_reads;
u32 n_erasures;
u32 n_unmarked_deletions;
u32 refresh_count;
u32 cache_hits;
+ u32 tags_used;
+ u32 summary_used;
};
#include "yaffs_tagscompat.h"
#include "yaffs_getblockinfo.h"
+#include "yaffs_summary.h"
int yaffs_rd_chunk_tags_nand(struct yaffs_dev *dev, int nand_chunk,
u8 *buffer, struct yaffs_ext_tags *tags)
{
int result;
struct yaffs_ext_tags local_tags;
- int realigned_chunk = nand_chunk - dev->chunk_offset;
+ int flash_chunk = nand_chunk - dev->chunk_offset;
dev->n_page_reads++;
if (dev->param.read_chunk_tags_fn)
result =
- dev->param.read_chunk_tags_fn(dev, realigned_chunk, buffer,
+ dev->param.read_chunk_tags_fn(dev, flash_chunk, buffer,
tags);
else
result = yaffs_tags_compat_rd(dev,
- realigned_chunk, buffer, tags);
+ flash_chunk, buffer, tags);
if (tags && tags->ecc_result > YAFFS_ECC_RESULT_NO_ERROR) {
struct yaffs_block_info *bi;
int nand_chunk,
const u8 *buffer, struct yaffs_ext_tags *tags)
{
+ int result;
+ int flash_chunk = nand_chunk - dev->chunk_offset;
+
dev->n_page_writes++;
- nand_chunk -= dev->chunk_offset;
if (tags) {
tags->seq_number = dev->seq_number;
}
if (dev->param.write_chunk_tags_fn)
- return dev->param.write_chunk_tags_fn(dev, nand_chunk, buffer,
- tags);
+ result = dev->param.write_chunk_tags_fn(dev, flash_chunk,
+ buffer, tags);
+ else
+ result = yaffs_tags_compat_wr(dev, flash_chunk, buffer, tags);
- return yaffs_tags_compat_wr(dev, nand_chunk, buffer, tags);
+ yaffs_summary_add(dev, tags, nand_chunk);
+
+ return result;
}
int yaffs_mark_bad(struct yaffs_dev *dev, int block_no)
--- /dev/null
+/*
+ * 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"
+
+/* 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;
+};
+
+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));
+}
+
+int yaffs_summary_init(struct yaffs_dev *dev)
+{
+ int sum_bytes;
+ int chunks_used; /* Number of chunks used by summary */
+
+ 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;
+ dev->chunks_per_summary = dev->param.chunks_per_block - chunks_used;
+ dev->sum_tags = kmalloc(sizeof(struct yaffs_summary_tags) *
+ dev->chunks_per_summary, GFP_NOFS);
+ dev->gc_sum_tags = kmalloc(sizeof(struct yaffs_summary_tags) *
+ dev->chunks_per_summary, GFP_NOFS);
+ if(!dev->sum_tags || !dev->gc_sum_tags) {
+ kfree(dev->sum_tags);
+ kfree(dev->gc_sum_tags);
+ return YAFFS_FAIL;
+ }
+
+ yaffs_summary_clear(dev);
+
+ return YAFFS_OK;
+}
+
+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;
+}
+
+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_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;
+ do {
+ this_tx = n_bytes;
+ if (this_tx > dev->data_bytes_per_chunk)
+ this_tx = dev->data_bytes_per_chunk;
+ memcpy(buffer, sum_buffer, this_tx);
+ tags.n_bytes = this_tx;
+ 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++;
+
+ chunk_in_block++;
+ } 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_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;
+ 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 > dev->data_bytes_per_chunk)
+ this_tx = dev->data_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 ||
+ this_tx != tags.n_bytes)
+ 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(sum_buffer, buffer, 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 (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++;
+ }
+ }
+
+}
--- /dev/null
+/*
+ * 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 Lesser General Public License version 2.1 as
+ * published by the Free Software Foundation.
+ *
+ * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
+ */
+
+#ifndef __YAFFS_SUMMARY_H__
+#define __YAFFS_SUMMARY_H__
+
+#include "yaffs_packedtags2.h"
+
+
+int yaffs_summary_init(struct yaffs_dev *dev);
+void yaffs_summary_deinit(struct yaffs_dev *dev);
+
+int yaffs_summary_add(struct yaffs_dev *dev,
+ struct yaffs_ext_tags *tags,
+ int chunk_in_block);
+int yaffs_summary_fetch(struct yaffs_dev *dev,
+ struct yaffs_ext_tags *tags,
+ int chunk_in_block);
+int yaffs_summary_read(struct yaffs_dev *dev,
+ struct yaffs_summary_tags *st,
+ int blk);
+void yaffs_summary_gc(struct yaffs_dev *dev, int blk);
+
+
+#endif
int lazy_loading_overridden;
int empty_lost_and_found;
int empty_lost_and_found_overridden;
+ int disable_summary;
};
#define MAX_OPT_LEN 30
} else if (!strcmp(cur_opt, "lazy-loading-on")) {
options->lazy_loading_enabled = 1;
options->lazy_loading_overridden = 1;
+ } else if (!strcmp(cur_opt, "disable_summary")) {
+ options->disable_summary = 1;
} else if (!strcmp(cur_opt, "empty-lost-and-found-off")) {
options->empty_lost_and_found = 0;
options->empty_lost_and_found_overridden = 1;
param->empty_lost_n_found = 1;
param->refresh_period = 500;
+ param->disable_summary = options.disable_summary;
if (options.empty_lost_and_found_overridden)
param->empty_lost_n_found = options.empty_lost_and_found;
dev->n_unlinked_files);
buf += sprintf(buf, "refresh_count........ %u\n", dev->refresh_count);
buf += sprintf(buf, "n_bg_deletions....... %u\n", dev->n_bg_deletions);
+ buf += sprintf(buf, "tags_used............ %u\n", dev->tags_used);
+ buf += sprintf(buf, "summary_used......... %u\n", dev->summary_used);
return buf;
}
#include "yaffs_getblockinfo.h"
#include "yaffs_verify.h"
#include "yaffs_attribs.h"
+#include "yaffs_summary.h"
/*
* Checkpoints are really no benefit on very small partitions.
int blk, int chunk_in_block,
int *found_chunks,
u8 *chunk_data,
- struct list_head *hard_list)
+ struct list_head *hard_list,
+ int summary_available)
{
struct yaffs_obj_hdr *oh;
struct yaffs_obj *in;
struct yaffs_hardlink_var *hl_var;
struct yaffs_symlink_var *sl_var;
- result = yaffs_rd_chunk_tags_nand(dev, chunk, NULL, &tags);
+ if (summary_available) {
+ result = yaffs_summary_fetch(dev, &tags, chunk_in_block);
+ tags.seq_number = bi->seq_number;
+ }
+
+ if (!summary_available || tags.obj_id == 0) {
+ result = yaffs_rd_chunk_tags_nand(dev, chunk, NULL, &tags);
+ dev->tags_used++;
+ } else {
+ dev->summary_used++;
+ }
/* Let's have a good look at this chunk... */
int alloc_failed = 0;
struct yaffs_block_index *block_index = NULL;
int alt_block_index = 0;
+ int summary_available;
yaffs_trace(YAFFS_TRACE_SCAN,
"yaffs2_scan_backwards starts intstartblk %d intendblk %d...",
bi = yaffs_get_block_info(dev, blk);
deleted = 0;
+ summary_available = yaffs_summary_read(dev, dev->sum_tags, blk);
+
/* For each chunk in each block that needs scanning.... */
found_chunks = 0;
- for (c = dev->param.chunks_per_block - 1;
+ if(summary_available)
+ c = dev->chunks_per_summary - 1;
+ else
+ c = dev->param.chunks_per_block - 1;
+
+ for (/* c is already initialised */;
!alloc_failed && c >= 0 &&
(bi->block_state == YAFFS_BLOCK_STATE_NEEDS_SCAN ||
- bi->block_state == YAFFS_BLOCK_STATE_ALLOCATING); c--) {
+ bi->block_state == YAFFS_BLOCK_STATE_ALLOCATING);
+ c--) {
/* Scan backwards...
* Read the tags and decide what to do
*/
if (yaffs2_scan_chunk(dev, bi, blk, c,
&found_chunks, chunk_data,
- &hard_list) == YAFFS_FAIL)
+ &hard_list, summary_available) ==
+ YAFFS_FAIL)
alloc_failed = 1;
}