#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
/* Function to calculate chunk and offset */
-static inline void yaffs_addr_to_chunk(struct yaffs_dev *dev, loff_t addr,
- int *chunk_out, u32 *offset_out)
+void yaffs_addr_to_chunk(struct yaffs_dev *dev, loff_t addr,
+ int *chunk_out, u32 *offset_out)
{
int chunk;
u32 offset;
if (buffer) {
/* assume it is an unmanaged one. */
- yaffs_trace(YAFFS_TRACE_BUFFERS, "Releasing unmanaged temp buffer");
+ yaffs_trace(YAFFS_TRACE_BUFFERS,
+ "Releasing unmanaged temp buffer");
kfree(buffer);
dev->unmanaged_buffer_deallocs++;
}
}
-/*
- * Determine if we have a managed buffer.
- */
-int yaffs_is_managed_tmp_buffer(struct yaffs_dev *dev, const u8 *buffer)
-{
- int i;
-
- for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) {
- if (dev->temp_buffer[i].buffer == buffer)
- return 1;
- }
-
- for (i = 0; i < dev->param.n_caches; i++) {
- if (dev->cache[i].data == buffer)
- return 1;
- }
-
- if (buffer == dev->checkpt_buffer)
- return 1;
-
- yaffs_trace(YAFFS_TRACE_ALWAYS,
- "yaffs: unmaged buffer detected.");
- return 0;
-}
-
/*
* Functions for robustisizing TODO
*
const u8 *data,
const struct yaffs_ext_tags *tags)
{
- dev = dev;
- nand_chunk = nand_chunk;
- data = data;
- tags = tags;
+ (void) dev;
+ (void) nand_chunk;
+ (void) data;
+ (void) tags;
}
static void yaffs_handle_chunk_update(struct yaffs_dev *dev, int nand_chunk,
const struct yaffs_ext_tags *tags)
{
- dev = dev;
- nand_chunk = nand_chunk;
- tags = tags;
+ (void) dev;
+ (void) nand_chunk;
+ (void) tags;
}
void yaffs_handle_chunk_error(struct yaffs_dev *dev,
static inline int yaffs_hash_fn(int n)
{
- n = abs(n);
+ if (n < 0)
+ n = -n;
return n % YAFFS_NOBJECT_BUCKETS;
}
yaffs_trace(YAFFS_TRACE_ERROR,
"**>> yaffs write required %d attempts",
attempts);
- dev->n_retired_writes += (attempts - 1);
+ dev->n_retried_writes += (attempts - 1);
}
return chunk;
void yaffs_set_obj_name(struct yaffs_obj *obj, const YCHAR * name)
{
-#ifndef CONFIG_YAFFS_NO_SHORT_NAMES
memset(obj->short_name, 0, sizeof(obj->short_name));
if (name &&
strnlen(name, YAFFS_SHORT_NAME_LENGTH + 1) <=
strcpy(obj->short_name, name);
else
obj->short_name[0] = _Y('\0');
-#endif
obj->sum = yaffs_calc_name_sum(name);
}
#endif
}
+loff_t yaffs_max_file_size(struct yaffs_dev *dev)
+{
+ if(sizeof(loff_t) < 8)
+ return YAFFS_MAX_FILE_SIZE_32;
+ else
+ return ((loff_t) YAFFS_MAX_CHUNK_ID) * dev->data_bytes_per_chunk;
+}
+
/*-------------------- TNODES -------------------
* List of spare tnodes
dev->n_tnodes = 0;
}
-void yaffs_load_tnode_0(struct yaffs_dev *dev, struct yaffs_tnode *tn,
+static void yaffs_load_tnode_0(struct yaffs_dev *dev, struct yaffs_tnode *tn,
unsigned pos, unsigned val)
{
u32 *map = (u32 *) tn;
int required_depth;
int level = file_struct->top_level;
- dev = dev;
+ (void) dev;
/* Check sane level and chunk Id */
if (level < 0 || level > YAFFS_TNODES_MAX_LEVEL)
return NULL;
}
-struct yaffs_obj *yaffs_new_obj(struct yaffs_dev *dev, int number,
+static struct yaffs_obj *yaffs_new_obj(struct yaffs_dev *dev, int number,
enum yaffs_obj_type type)
{
struct yaffs_obj *the_obj = NULL;
case YAFFS_OBJECT_TYPE_FILE:
the_obj->variant.file_variant.file_size = 0;
the_obj->variant.file_variant.scanned_size = 0;
- the_obj->variant.file_variant.shrink_size = ~0; /* max */
+ the_obj->variant.file_variant.shrink_size =
+ yaffs_max_file_size(dev);
the_obj->variant.file_variant.top_level = 0;
the_obj->variant.file_variant.top = tn;
break;
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);
/* Update file size */
if (object->variant_type == YAFFS_OBJECT_TYPE_FILE) {
- oh->file_size =
+ yaffs_oh_size_load(oh,
+ object->variant.file_variant.file_size);
+ tags.extra_file_size =
object->variant.file_variant.file_size;
- tags.extra_length = oh->file_size;
}
yaffs_verify_oh(object, oh, &tags, 1);
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",
}
} else {
#else
+ (void) dev;
{
#endif
strncpy(name, oh_name, buff_size - 1);
}
} else {
#else
+ dev = dev;
{
#endif
strncpy(oh_name, name, YAFFS_MAX_NAME_LENGTH - 1);
u8 *buffer = NULL;
YCHAR old_name[YAFFS_MAX_NAME_LENGTH + 1];
struct yaffs_obj_hdr *oh = NULL;
+ loff_t file_size = 0;
strcpy(old_name, _Y("silly old name"));
/* Should not happen */
break;
case YAFFS_OBJECT_TYPE_FILE:
- oh->file_size =
- (oh->parent_obj_id == YAFFS_OBJECTID_DELETED ||
- oh->parent_obj_id == YAFFS_OBJECTID_UNLINKED) ?
- 0 : in->variant.file_variant.file_size;
+ if (oh->parent_obj_id != YAFFS_OBJECTID_DELETED &&
+ oh->parent_obj_id != YAFFS_OBJECTID_UNLINKED)
+ file_size = in->variant.file_variant.file_size;
+ yaffs_oh_size_load(oh, file_size);
break;
case YAFFS_OBJECT_TYPE_HARDLINK:
oh->equiv_id = in->variant.hardlink_variant.equiv_id;
/* Add extra info for file header */
new_tags.extra_available = 1;
new_tags.extra_parent_id = oh->parent_obj_id;
- new_tags.extra_length = oh->file_size;
+ new_tags.extra_file_size = file_size;
new_tags.extra_is_shrink = oh->is_shrink;
new_tags.extra_equiv_id = oh->equiv_id;
new_tags.extra_shadows = (oh->shadows_obj > 0) ? 1 : 0;
}
int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset,
- int n_bytes, int write_trhrough)
+ int n_bytes, int write_through)
{
int chunk;
int n = n_bytes;
int n_done = 0;
int n_writeback;
- int start_write = offset;
+ loff_t start_write = offset;
int chunk_written = 0;
u32 n_bytes_read;
- u32 chunk_start;
+ loff_t chunk_start;
struct yaffs_dev *dev;
dev = in->my_dev;
while (n > 0 && chunk_written >= 0) {
yaffs_addr_to_chunk(dev, offset, &chunk, &start);
- if (chunk * dev->data_bytes_per_chunk + start != offset ||
+ if (((loff_t)chunk) *
+ dev->data_bytes_per_chunk + start != offset ||
start >= dev->data_bytes_per_chunk) {
yaffs_trace(YAFFS_TRACE_ERROR,
- "AddrToChunk of offset %d gives chunk %d start %d",
- (int)offset, chunk, start);
+ "AddrToChunk of offset %lld gives chunk %d start %d",
+ offset, chunk, start);
}
chunk++; /* File pos to chunk in file offset */
* before.
*/
- chunk_start = ((chunk - 1) * dev->data_bytes_per_chunk);
+ chunk_start = (((loff_t)(chunk - 1)) *
+ dev->data_bytes_per_chunk);
if (chunk_start > in->variant.file_variant.file_size)
n_bytes_read = 0; /* Past end of file */
cache->locked = 0;
cache->n_bytes = n_writeback;
- if (write_trhrough) {
+ if (write_through) {
chunk_written =
yaffs_wr_data_obj
(cache->object,
}
int yaffs_wr_file(struct yaffs_obj *in, const u8 *buffer, loff_t offset,
- int n_bytes, int write_trhrough)
+ int n_bytes, int write_through)
{
yaffs2_handle_hole(in, offset);
- return yaffs_do_file_wr(in, buffer, offset, n_bytes, write_trhrough);
+ return yaffs_do_file_wr(in, buffer, offset, n_bytes, write_through);
}
/* ---------------------- File resizing stuff ------------------ */
-static void yaffs_prune_chunks(struct yaffs_obj *in, int new_size)
+static void yaffs_prune_chunks(struct yaffs_obj *in, loff_t new_size)
{
struct yaffs_dev *dev = in->my_dev;
- int old_size = in->variant.file_variant.file_size;
+ loff_t old_size = in->variant.file_variant.file_size;
int i;
int chunk_id;
- int last_del = 1 + (old_size - 1) / dev->data_bytes_per_chunk;
- int start_del = 1 + (new_size + dev->data_bytes_per_chunk - 1) /
- dev->data_bytes_per_chunk;
+ u32 dummy;
+ int last_del;
+ int start_del;
+
+ if (old_size > 0)
+ yaffs_addr_to_chunk(dev, old_size - 1, &last_del, &dummy);
+ else
+ last_del = 0;
+ yaffs_addr_to_chunk(dev, new_size + dev->data_bytes_per_chunk - 1,
+ &start_del, &dummy);
+ last_del++;
+ start_del++;
/* Delete backwards so that we don't end up with holes if
* power is lost part-way through the operation.
int yaffs_resize_file(struct yaffs_obj *in, loff_t new_size)
{
struct yaffs_dev *dev = in->my_dev;
- int old_size = in->variant.file_variant.file_size;
+ loff_t old_size = in->variant.file_variant.file_size;
yaffs_flush_file_cache(in);
yaffs_invalidate_whole_cache(in);
return ret_val;
}
-int yaffs_del_file(struct yaffs_obj *in)
+static int yaffs_del_file(struct yaffs_obj *in)
{
int ret_val = YAFFS_OK;
int deleted; /* Need to cache value on stack if in is freed */
*/
yaffs_get_obj_name(l, buffer,
YAFFS_MAX_NAME_LENGTH + 1);
- if (strncmp(name, buffer, YAFFS_MAX_NAME_LENGTH) == 0)
+ if (!strncmp(name, buffer, YAFFS_MAX_NAME_LENGTH))
return l;
}
}
{
memset(name, 0, buffer_size * sizeof(YCHAR));
yaffs_check_obj_details_loaded(obj);
- if (obj->obj_id == YAFFS_OBJECTID_LOSTNFOUND)
+ if (obj->obj_id == YAFFS_OBJECTID_LOSTNFOUND) {
strncpy(name, YAFFS_LOSTNFOUND_NAME, buffer_size - 1);
-#ifndef CONFIG_YAFFS_NO_SHORT_NAMES
- else if (obj->short_name[0])
+ } else if (obj->short_name[0]) {
strcpy(name, obj->short_name);
-#endif
- else if (obj->hdr_chunk > 0) {
+ } else if (obj->hdr_chunk > 0) {
int result;
u8 *buffer = yaffs_get_temp_buffer(obj->my_dev);
return strnlen(name, YAFFS_MAX_NAME_LENGTH);
}
-int yaffs_get_obj_length(struct yaffs_obj *obj)
+loff_t yaffs_get_obj_length(struct yaffs_obj *obj)
{
/* Dereference any hard linking */
obj = yaffs_get_equivalent_obj(obj);
if (!dev->param.erase_fn || !dev->param.initialise_flash_fn)
return 0;
-#ifdef CONFIG_YAFFS_YAFFS2
-
/* Can use the "with tags" style interface for yaffs1 or yaffs2 */
if (dev->param.write_chunk_tags_fn &&
dev->param.read_chunk_tags_fn &&
!dev->param.read_chunk_fn &&
dev->param.bad_block_fn && dev->param.query_block_fn)
return 1;
-#endif
/* Can use the "spare" style interface for yaffs1 */
if (!dev->param.is_yaffs2 &&
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) {
dev->n_page_writes = 0;
dev->n_erasures = 0;
dev->n_gc_copies = 0;
- dev->n_retired_writes = 0;
+ dev->n_retried_writes = 0;
dev->n_retired_blocks = 0;
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++) {
return n_free;
}
+
+/*
+ * Marshalling functions to get loff_t file sizes into and out of
+ * object headers.
+ */
+void yaffs_oh_size_load(struct yaffs_obj_hdr *oh, loff_t fsize)
+{
+ oh->file_size_low = (fsize & 0xFFFFFFFF);
+ oh->file_size_high = ((fsize >> 32) & 0xFFFFFFFF);
+}
+
+loff_t yaffs_oh_to_size(struct yaffs_obj_hdr *oh)
+{
+ loff_t retval;
+
+ if (sizeof(loff_t) >= 8 && ~(oh->file_size_high))
+ retval = (((loff_t) oh->file_size_high) << 32) |
+ (((loff_t) oh->file_size_low) & 0xFFFFFFFF);
+ else
+ retval = (loff_t) oh->file_size_low;
+
+ return retval;
+}
projects / yaffs2.git / blobdiff