lkml.org 
[lkml]   [2011]   [Jan]   [19]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
Patch in this message
/
Date
From
SubjectRe: [PATCH 07/10] Add yaffs2 file system: yaffs1 and yaffs2 mode specific code
On 01/14/2011 04:06 PM, Charles Manning wrote:
> Signed-off-by: Charles Manning <cdhmanning@gmail.com>

More comments below.

~Ryan

> ---
> fs/yaffs2/yaffs_yaffs1.c | 423 +++++++++++++
> fs/yaffs2/yaffs_yaffs1.h | 22 +
> fs/yaffs2/yaffs_yaffs2.c | 1516 ++++++++++++++++++++++++++++++++++++++++++++++
> fs/yaffs2/yaffs_yaffs2.h | 39 ++
> 4 files changed, 2000 insertions(+), 0 deletions(-)
> create mode 100644 fs/yaffs2/yaffs_yaffs1.c
> create mode 100644 fs/yaffs2/yaffs_yaffs1.h
> create mode 100644 fs/yaffs2/yaffs_yaffs2.c
> create mode 100644 fs/yaffs2/yaffs_yaffs2.h
>
> diff --git a/fs/yaffs2/yaffs_yaffs1.c b/fs/yaffs2/yaffs_yaffs1.c
> new file mode 100644
> index 0000000..6ee91a1
> --- /dev/null
> +++ b/fs/yaffs2/yaffs_yaffs1.c
> @@ -0,0 +1,423 @@
> +/*
> + * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
> + *
> + * Copyright (C) 2002-2010 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.
> + */
> +
> +#include "yaffs_yaffs1.h"
> +#include "yportenv.h"
> +#include "yaffs_trace.h"
> +#include "yaffs_bitmap.h"
> +#include "yaffs_getblockinfo.h"
> +#include "yaffs_nand.h"
> +#include "yaffs_attribs.h"
> +
> +int yaffs1_scan(struct yaffs_dev *dev)
> +{
> + struct yaffs_ext_tags tags;
> + int blk;
> + int result;
> + int chunk;
> + int c;
> + int deleted;

int blk, result, chunk, c, deleted;

etc, will save some lines.

> + enum yaffs_block_state state;
> + struct yaffs_obj *hard_list = NULL;
> + struct yaffs_block_info *bi;
> + u32 seq_number;
> + struct yaffs_obj_hdr *oh;
> + struct yaffs_obj *in;
> + struct yaffs_obj *parent;
> + int alloc_failed = 0;
> + struct yaffs_shadow_fixer *shadow_fixers = NULL;
> + u8 *chunk_data;
> +
> + yaffs_trace(YAFFS_TRACE_SCAN,
> + "yaffs1_scan starts intstartblk %d intendblk %d...",
> + dev->internal_start_block, dev->internal_end_block);
> +
> + chunk_data = yaffs_get_temp_buffer(dev, __LINE__);
> +
> + dev->seq_number = YAFFS_LOWEST_SEQUENCE_NUMBER;
> +
> + /* Scan all the blocks to determine their state */
> + bi = dev->block_info;
> + for (blk = dev->internal_start_block; blk <= dev->internal_end_block;
> + blk++) {
> + yaffs_clear_chunk_bits(dev, blk);
> + bi->pages_in_use = 0;
> + bi->soft_del_pages = 0;
> +
> + yaffs_query_init_block_state(dev, blk, &state, &seq_number);
> +
> + bi->block_state = state;
> + bi->seq_number = seq_number;
> +
> + if (bi->seq_number == YAFFS_SEQUENCE_BAD_BLOCK)
> + bi->block_state = state = YAFFS_BLOCK_STATE_DEAD;
> +
> + yaffs_trace(YAFFS_TRACE_SCAN_DEBUG,
> + "Block scanning block %d state %d seq %d",
> + blk, state, seq_number);
> +
> + if (state == YAFFS_BLOCK_STATE_DEAD) {
> + yaffs_trace(YAFFS_TRACE_BAD_BLOCKS,
> + "block %d is bad", blk);
> + } else if (state == YAFFS_BLOCK_STATE_EMPTY) {
> + yaffs_trace(YAFFS_TRACE_SCAN_DEBUG, "Block empty ");
> + dev->n_erased_blocks++;
> + dev->n_free_chunks += dev->param.chunks_per_block;
> + }
> + bi++;
> + }
> +
> + /* For each block.... */
> + for (blk = dev->internal_start_block;
> + !alloc_failed && blk <= dev->internal_end_block; blk++) {
> +
> + cond_resched();
> +
> + bi = yaffs_get_block_info(dev, blk);
> + state = bi->block_state;
> +
> + deleted = 0;
> +
> + /* For each chunk in each block that needs scanning.... */
> + for (c = 0; !alloc_failed && c < dev->param.chunks_per_block &&
> + state == YAFFS_BLOCK_STATE_NEEDS_SCANNING; c++) {

Maybe worth breaking parts of the body of this loop into sub functions
to reduce the indentation level and make everything a bit more readable.

> + /* Read the tags and decide what to do */
> + chunk = blk * dev->param.chunks_per_block + c;
> +
> + result = yaffs_rd_chunk_tags_nand(dev, chunk, NULL,
> + &tags);
> +
> + /* Let's have a good look at this chunk... */
> +
> + if (tags.ecc_result == YAFFS_ECC_RESULT_UNFIXED
> + || tags.is_deleted) {
> + /* YAFFS1 only...
> + * A deleted chunk
> + */
> + deleted++;
> + dev->n_free_chunks++;
> + } else if (!tags.chunk_used) {
> + /* An unassigned chunk in the block
> + * This means that either the block is empty or
> + * this is the one being allocated from
> + */
> +
> + if (c == 0) {
> + /* We're looking at the first chunk in
> + *the block so the block is unused */
> + state = YAFFS_BLOCK_STATE_EMPTY;
> + dev->n_erased_blocks++;
> + } else {
> + /* this is the block being allocated */
> + yaffs_trace(YAFFS_TRACE_SCAN,
> + " Allocating from %d %d",
> + blk, c);
> + state = YAFFS_BLOCK_STATE_ALLOCATING;
> + dev->alloc_block = blk;
> + dev->alloc_page = c;
> + dev->alloc_block_finder = blk;
> +
> + }
> +
> + dev->n_free_chunks +=
> + (dev->param.chunks_per_block - c);
> + } else if (tags.chunk_id > 0) {
> + /* chunk_id > 0 so it is a data chunk... */
> + unsigned int endpos;
> +
> + yaffs_set_chunk_bit(dev, blk, c);
> + bi->pages_in_use++;
> +
> + in = yaffs_find_or_create_by_number(dev,
> + tags.obj_id,
> + YAFFS_OBJECT_TYPE_FILE);
> + /* PutChunkIntoFile checks for a clash
> + * (two data chunks with the same chunk_id).
> + */
> +
> + if (!in)
> + alloc_failed = 1;
> +
> + if (in) {
> + if (!yaffs_put_chunk_in_file
> + (in, tags.chunk_id, chunk, 1))
> + alloc_failed = 1;
> + }

This looks like it could be simplified a little by replacing
'alloc_failed = 1' statement with a 'goto alloc_failed'. It means that
you don't have keep checking to make sure in is valid.

> +
> + endpos =
> + (tags.chunk_id - 1) *
> + dev->data_bytes_per_chunk +
> + tags.n_bytes;
> + if (in &&
> + in->variant_type ==
> + YAFFS_OBJECT_TYPE_FILE &&
> + in->variant.file_variant.scanned_size <
> + endpos) {
> + in->variant.file_variant.scanned_size =
> + endpos;
> + if (!dev->param.use_header_file_size) {
> + in->variant.
> + file_variant.file_size =
> + in->variant.
> + file_variant.scanned_size;
> + }
> +
> + }
> + } else {
> + /* chunk_id == 0, so it is an ObjectHeader.
> + * Make the object
> + */
> + yaffs_set_chunk_bit(dev, blk, c);
> + bi->pages_in_use++;
> +
> + result = yaffs_rd_chunk_tags_nand(dev, chunk,
> + chunk_data,
> + NULL);
> +
> + oh = (struct yaffs_obj_hdr *)chunk_data;
> +
> + in = yaffs_find_by_number(dev, tags.obj_id);
> + if (in && in->variant_type != oh->type) {
> + /* This should not happen, but somehow
> + * Wev'e ended up with an obj_id that
> + * has been reused but not yet deleted,
> + * and worse still it has changed type.
> + * Delete the old object.
> + */
> +
> + yaffs_del_obj(in);
> + in = NULL;

You don't need the assignment to NULL here.

> + }
> +
> + in = yaffs_find_or_create_by_number(dev,
> + tags.obj_id,
> + oh->type);
> +
> + if (!in)
> + alloc_failed = 1;
> +
> + if (in && oh->shadows_obj > 0) {
> +
> + struct yaffs_shadow_fixer *fixer;
> + fixer =
> + kmalloc(sizeof
> + (struct yaffs_shadow_fixer),
> + GFP_NOFS);

if (!fixer)? Do we want a warning?

Fixers could also use struct list_head rather than their own (albeit
simple) linked list implementation.

> + if (fixer) {
> + fixer->next = shadow_fixers;
> + shadow_fixers = fixer;
> + fixer->obj_id = tags.obj_id;
> + fixer->shadowed_id =
> + oh->shadows_obj;
> + yaffs_trace(YAFFS_TRACE_SCAN,
> + " Shadow fixer: %d shadows %d",
> + fixer->obj_id,
> + fixer->shadowed_id);
> +
> + }
> +
> + }
> +
> + if (in && in->valid) {
> + /* We have already filled this one.
> + * We have a duplicate and need to
> + * resolve it. */
> +
> + unsigned existing_serial = in->serial;
> + unsigned new_serial =
> + tags.serial_number;
> +
> + if (((existing_serial + 1) & 3) ==
> + new_serial) {
> + /* Use new one - destroy the
> + * exisiting one */
> + yaffs_chunk_del(dev,
> + in->hdr_chunk,
> + 1, __LINE__);
> + in->valid = 0;
> + } else {
> + /* Use existing - destroy
> + * this one. */
> + yaffs_chunk_del(dev, chunk, 1,
> + __LINE__);
> + }
> + }
> +
> + if (in && !in->valid &&
> + (tags.obj_id == YAFFS_OBJECTID_ROOT ||
> + tags.obj_id ==
> + YAFFS_OBJECTID_LOSTNFOUND)) {
> + /* We only load some info, don't fiddle
> + * with directory structure */
> + in->valid = 1;
> + in->variant_type = oh->type;
> +
> + in->yst_mode = oh->yst_mode;
> + yaffs_load_attribs(in, oh);
> + in->hdr_chunk = chunk;
> + in->serial = tags.serial_number;
> +
> + } else if (in && !in->valid) {
> + /* we need to load this info */
> +
> + in->valid = 1;
> + in->variant_type = oh->type;
> +
> + in->yst_mode = oh->yst_mode;
> + yaffs_load_attribs(in, oh);
> + in->hdr_chunk = chunk;
> + in->serial = tags.serial_number;
> +
> + yaffs_set_obj_name_from_oh(in, oh);
> + in->dirty = 0;
> +
> + /* directory stuff...
> + * hook up to parent
> + */
> +
> + parent =
> + yaffs_find_or_create_by_number
> + (dev, oh->parent_obj_id,
> + YAFFS_OBJECT_TYPE_DIRECTORY);
> + if (!parent)
> + alloc_failed = 1;

Again, using a goto to get out of the loop here will simplify the if
statements below.

> + if (parent && parent->variant_type ==
> + YAFFS_OBJECT_TYPE_UNKNOWN) {
> + /* Set up as a directory */
> + parent->variant_type =
> + YAFFS_OBJECT_TYPE_DIRECTORY;
> + INIT_LIST_HEAD(&parent->
> + variant.dir_variant.
> + children);
> + } else if (!parent ||
> + parent->variant_type !=
> + YAFFS_OBJECT_TYPE_DIRECTORY) {
> + /* Hoosterman, a problem....
> + * We're trying to use a
> + * non-directory as a directory
> + */

You can drop this comment, the yaffs_trace has the same information.

> +
> + yaffs_trace(YAFFS_TRACE_ERROR,
> + "yaffs tragedy: attempting to use non-directory as a directory in scan. Put in lost+found."
> + );
> + parent = dev->lost_n_found;
> + }
> +
> + yaffs_add_obj_to_dir(parent, in);
> +
> + switch (in->variant_type) {
> + case YAFFS_OBJECT_TYPE_UNKNOWN:
> + /* Todo got a problem */

Warning?

> + break;
> + case YAFFS_OBJECT_TYPE_FILE:
> + if (dev->param.
> + use_header_file_size)
> +
> + in->variant.
> + file_variant.file_size
> + = oh->file_size;
> +
> + break;
> + case YAFFS_OBJECT_TYPE_HARDLINK:
> + in->variant.
> + hardlink_variant.equiv_id =
> + oh->equiv_id;
> + in->hard_links.next =
> + (struct list_head *)
> + hard_list;

More linked list casting weirdness?

> + hard_list = in;
> + break;
> + case YAFFS_OBJECT_TYPE_DIRECTORY:
> + /* Do nothing */
> + break;
> + case YAFFS_OBJECT_TYPE_SPECIAL:
> + /* Do nothing */
> + break;
> + case YAFFS_OBJECT_TYPE_SYMLINK:
> + in->variant.symlink_variant.
> + alias =
> + yaffs_clone_str(oh->alias);
> + if (!in->variant.
> + symlink_variant.alias)
> + alloc_failed = 1;
> + break;
> + }
> + }
> + }
> + }
> +
> + if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING) {
> + /* If we got this far while scanning,
> + * then the block is fully allocated. */
> + state = YAFFS_BLOCK_STATE_FULL;
> + }
> +
> + if (state == YAFFS_BLOCK_STATE_ALLOCATING) {
> + /* If the block was partially allocated then
> + * treat it as fully allocated. */
> + state = YAFFS_BLOCK_STATE_FULL;
> + dev->alloc_block = -1;
> + }
> +
> + bi->block_state = state;
> +
> + /* Now let's see if it was dirty */
> + if (bi->pages_in_use == 0 &&
> + !bi->has_shrink_hdr &&
> + bi->block_state == YAFFS_BLOCK_STATE_FULL) {
> + yaffs_block_became_dirty(dev, blk);
> + }
> + }
> +
> + /* Ok, we've done all the scanning.
> + * Fix up the hard link chains.
> + * We should now have scanned all the objects, now it's time to add
> + * these hardlinks.
> + */
> +
> + yaffs_link_fixup(dev, hard_list);
> +
> + /* Fix up any shadowed objects */
> + {
> + struct yaffs_shadow_fixer *fixer;
> + struct yaffs_obj *obj;

Move these to the top of the function (or reuse existing ones) and
remove a level of indentation :-)

> +
> + while (shadow_fixers) {
> + fixer = shadow_fixers;
> + shadow_fixers = fixer->next;
> + /* Complete the rename transaction by deleting the
> + * shadowed object then setting the object header
> + to unshadowed.
> + */
> + obj = yaffs_find_by_number(dev, fixer->shadowed_id);
> + if (obj)
> + yaffs_del_obj(obj);
> +
> + obj = yaffs_find_by_number(dev, fixer->obj_id);
> +
> + if (obj)
> + yaffs_update_oh(obj, NULL, 1, 0, 0, NULL);
> +
> + kfree(fixer);
> + }
> + }
> +
> + yaffs_release_temp_buffer(dev, chunk_data, __LINE__);
> +
> + if (alloc_failed)
> + return YAFFS_FAIL;
> +
> + yaffs_trace(YAFFS_TRACE_SCAN, "yaffs1_scan ends");
> +
> + return YAFFS_OK;
> +}
> diff --git a/fs/yaffs2/yaffs_yaffs1.h b/fs/yaffs2/yaffs_yaffs1.h
> new file mode 100644
> index 0000000..db23e04
> --- /dev/null
> +++ b/fs/yaffs2/yaffs_yaffs1.h
> @@ -0,0 +1,22 @@
> +/*
> + * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
> + *
> + * Copyright (C) 2002-2010 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_YAFFS1_H__
> +#define __YAFFS_YAFFS1_H__
> +
> +#include "yaffs_guts.h"
> +int yaffs1_scan(struct yaffs_dev *dev);
> +
> +#endif
> diff --git a/fs/yaffs2/yaffs_yaffs2.c b/fs/yaffs2/yaffs_yaffs2.c
> new file mode 100644
> index 0000000..77101e7
> --- /dev/null
> +++ b/fs/yaffs2/yaffs_yaffs2.c
> @@ -0,0 +1,1516 @@
> +/*
> + * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
> + *
> + * Copyright (C) 2002-2010 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.
> + */
> +
> +#include "yaffs_guts.h"
> +#include "yaffs_trace.h"
> +#include "yaffs_yaffs2.h"
> +#include "yaffs_checkptrw.h"
> +#include "yaffs_bitmap.h"
> +#include "yaffs_nand.h"
> +#include "yaffs_getblockinfo.h"
> +#include "yaffs_verify.h"
> +#include "yaffs_attribs.h"
> +
> +/*
> + * Checkpoints are really no benefit on very small partitions.
> + *
> + * To save space on small partitions don't bother with checkpoints unless
> + * the partition is at least this big.
> + */
> +#define YAFFS_CHECKPOINT_MIN_BLOCKS 60
> +#define YAFFS_SMALL_HOLE_THRESHOLD 4
> +
> +/*
> + * Oldest Dirty Sequence Number handling.
> + */
> +
> +/* yaffs_calc_oldest_dirty_seq()
> + * yaffs2_find_oldest_dirty_seq()
> + * Calculate the oldest dirty sequence number if we don't know it.
> + */
> +void yaffs_calc_oldest_dirty_seq(struct yaffs_dev *dev)
> +{
> + int i;
> + unsigned seq;
> + unsigned block_no = 0;
> + struct yaffs_block_info *b;
> +
> + if (!dev->param.is_yaffs2)
> + return;
> +
> + /* Find the oldest dirty sequence number. */
> + seq = dev->seq_number + 1;
> + b = dev->block_info;
> + for (i = dev->internal_start_block; i <= dev->internal_end_block; i++) {
> + if (b->block_state == YAFFS_BLOCK_STATE_FULL &&
> + (b->pages_in_use - b->soft_del_pages) <
> + dev->param.chunks_per_block && b->seq_number < seq) {
> + seq = b->seq_number;
> + block_no = i;
> + }
> + b++;
> + }
> +
> + if (block_no) {
> + dev->oldest_dirty_seq = seq;
> + dev->oldest_dirty_block = block_no;
> + }
> +}
> +
> +void yaffs2_find_oldest_dirty_seq(struct yaffs_dev *dev)
> +{
> + if (!dev->param.is_yaffs2)
> + return;
> +
> + if (!dev->oldest_dirty_seq)
> + yaffs_calc_oldest_dirty_seq(dev);
if (dev->param.is_yaffs2 && !dev->oldest_dirty_seq)
yaffs_calc_oldest_dirty_seq(dev);
Similar reductions are possible for other functions. Also, can we
actually end up here if dev->param.is_yaffs2 is not set?

> +}
> +
> +/*
> + * yaffs_clear_oldest_dirty_seq()
> + * Called when a block is erased or marked bad. (ie. when its seq_number
> + * becomes invalid). If the value matches the oldest then we clear
> + * dev->oldest_dirty_seq to force its recomputation.
> + */
> +void yaffs2_clear_oldest_dirty_seq(struct yaffs_dev *dev,
> + struct yaffs_block_info *bi)
> +{
> +
> + if (!dev->param.is_yaffs2)
> + return;
> +
> + if (!bi || bi->seq_number == dev->oldest_dirty_seq) {
> + dev->oldest_dirty_seq = 0;
> + dev->oldest_dirty_block = 0;
> + }
> +}
> +
> +/*
> + * yaffs2_update_oldest_dirty_seq()
> + * Update the oldest dirty sequence number whenever we dirty a block.
> + * Only do this if the oldest_dirty_seq is actually being tracked.
> + */
> +void yaffs2_update_oldest_dirty_seq(struct yaffs_dev *dev, unsigned block_no,
> + struct yaffs_block_info *bi)
> +{
> + if (!dev->param.is_yaffs2)
> + return;
> +
> + if (dev->oldest_dirty_seq) {
> + if (dev->oldest_dirty_seq > bi->seq_number) {
> + dev->oldest_dirty_seq = bi->seq_number;
> + dev->oldest_dirty_block = block_no;
> + }
> + }
> +}
> +
> +int yaffs_block_ok_for_gc(struct yaffs_dev *dev, struct yaffs_block_info *bi)
> +{
> +
> + if (!dev->param.is_yaffs2)
> + return 1; /* disqualification only applies to yaffs2. */
> +
> + if (!bi->has_shrink_hdr)
> + return 1; /* can gc */
> +
> + yaffs2_find_oldest_dirty_seq(dev);
> +
> + /* Can't do gc of this block if there are any blocks older than this
> + * one that have discarded pages.
> + */
> + return (bi->seq_number <= dev->oldest_dirty_seq);
> +}
> +
> +/*
> + * yaffs2_find_refresh_block()
> + * periodically finds the oldest full block by sequence number for refreshing.
> + * Only for yaffs2.
> + */
> +u32 yaffs2_find_refresh_block(struct yaffs_dev *dev)
> +{
> + u32 b;
> + u32 oldest = 0;
> + u32 oldest_seq = 0;
> + struct yaffs_block_info *bi;
> +
> + if (!dev->param.is_yaffs2)
> + return oldest;
> +
> + /*
> + * If refresh period < 10 then refreshing is disabled.
> + */
> + if (dev->param.refresh_period < 10)
> + return oldest;
> +
> + /*
> + * Fix broken values.
> + */
> + if (dev->refresh_skip > dev->param.refresh_period)
> + dev->refresh_skip = dev->param.refresh_period;
> +
> + if (dev->refresh_skip > 0)
> + return oldest;
> +
> + /*
> + * Refresh skip is now zero.
> + * We'll do a refresh this time around....
> + * Update the refresh skip and find the oldest block.
> + */
> + dev->refresh_skip = dev->param.refresh_period;
> + dev->refresh_count++;
> + bi = dev->block_info;
> + for (b = dev->internal_start_block; b <= dev->internal_end_block; b++) {
> +
> + if (bi->block_state == YAFFS_BLOCK_STATE_FULL) {
> +
> + if (oldest < 1 || bi->seq_number < oldest_seq) {
> + oldest = b;
> + oldest_seq = bi->seq_number;
> + }
> + }
> + bi++;
> + }
> +
> + if (oldest > 0) {
> + yaffs_trace(YAFFS_TRACE_GC,
> + "GC refresh count %d selected block %d with seq_number %d",
> + dev->refresh_count, oldest, oldest_seq);
> + }
> +
> + return oldest;
> +}
> +
> +int yaffs2_checkpt_required(struct yaffs_dev *dev)
> +{
> + int nblocks;
> +
> + if (!dev->param.is_yaffs2)
> + return 0;
> +
> + nblocks = dev->internal_end_block - dev->internal_start_block + 1;
> +
> + return !dev->param.skip_checkpt_wr &&
> + !dev->read_only && (nblocks >= YAFFS_CHECKPOINT_MIN_BLOCKS);
> +}
> +
> +int yaffs_calc_checkpt_blocks_required(struct yaffs_dev *dev)
> +{
> + int retval;
> +
> + if (!dev->param.is_yaffs2)
> + return 0;
> +
> + if (!dev->checkpoint_blocks_required && yaffs2_checkpt_required(dev)) {
> + /* Not a valid value so recalculate */
> + int n_bytes = 0;
> + int n_blocks;
> + int dev_blocks =
> + (dev->param.end_block - dev->param.start_block + 1);
> +
> + n_bytes += sizeof(struct yaffs_checkpt_validity);
> + n_bytes += sizeof(struct yaffs_checkpt_dev);
> + n_bytes += dev_blocks * sizeof(struct yaffs_block_info);
> + n_bytes += dev_blocks * dev->chunk_bit_stride;
> + n_bytes +=
> + (sizeof(struct yaffs_checkpt_obj) + sizeof(u32)) *
> + dev->n_obj;
> + n_bytes += (dev->tnode_size + sizeof(u32)) * dev->n_tnodes;
> + n_bytes += sizeof(struct yaffs_checkpt_validity);
> + n_bytes += sizeof(u32); /* checksum */
> +
> + /* Round up and add 2 blocks to allow for some bad blocks,
> + * so add 3 */
> +
> + n_blocks =
> + (n_bytes /
> + (dev->data_bytes_per_chunk *
> + dev->param.chunks_per_block)) + 3;
> +
> + dev->checkpoint_blocks_required = n_blocks;
> + }
> +
> + retval = dev->checkpoint_blocks_required - dev->blocks_in_checkpt;
> + if (retval < 0)
> + retval = 0;
> + return retval;
> +}
> +
> +/*--------------------- Checkpointing --------------------*/
> +
> +static int yaffs2_wr_checkpt_validity_marker(struct yaffs_dev *dev, int head)
> +{
> + struct yaffs_checkpt_validity cp;
> +
> + memset(&cp, 0, sizeof(cp));

Just initialise cp = {0} and drop the memset.
> + cp.struct_type = sizeof(cp);
> + cp.magic = YAFFS_MAGIC;
> + cp.version = YAFFS_CHECKPOINT_VERSION;
> + cp.head = (head) ? 1 : 0;

Don't need parens around head. Can also do:

cp.head = !!head;

> +
> + return (yaffs2_checkpt_wr(dev, &cp, sizeof(cp)) == sizeof(cp)) ? 1 : 0;
> +}
> +
> +static int yaffs2_rd_checkpt_validity_marker(struct yaffs_dev *dev, int head)
> +{
> + struct yaffs_checkpt_validity cp;
> + int ok;
> +
> + ok = (yaffs2_checkpt_rd(dev, &cp, sizeof(cp)) == sizeof(cp));
> +
> + if (ok)
> + ok = (cp.struct_type == sizeof(cp)) &&
> + (cp.magic == YAFFS_MAGIC) &&
> + (cp.version == YAFFS_CHECKPOINT_VERSION) &&
> + (cp.head == ((head) ? 1 : 0));

just cp.head == head should suffice.

> + return ok ? 1 : 0;
> +}
> +
> +static void yaffs2_dev_to_checkpt_dev(struct yaffs_checkpt_dev *cp,
> + struct yaffs_dev *dev)
> +{
> + cp->n_erased_blocks = dev->n_erased_blocks;
> + cp->alloc_block = dev->alloc_block;
> + cp->alloc_page = dev->alloc_page;
> + cp->n_free_chunks = dev->n_free_chunks;
> +
> + cp->n_deleted_files = dev->n_deleted_files;
> + cp->n_unlinked_files = dev->n_unlinked_files;
> + cp->n_bg_deletions = dev->n_bg_deletions;
> + cp->seq_number = dev->seq_number;
> +
> +}
> +
> +static void yaffs_checkpt_dev_to_dev(struct yaffs_dev *dev,
> + struct yaffs_checkpt_dev *cp)
> +{
> + dev->n_erased_blocks = cp->n_erased_blocks;
> + dev->alloc_block = cp->alloc_block;
> + dev->alloc_page = cp->alloc_page;
> + dev->n_free_chunks = cp->n_free_chunks;
> +
> + dev->n_deleted_files = cp->n_deleted_files;
> + dev->n_unlinked_files = cp->n_unlinked_files;
> + dev->n_bg_deletions = cp->n_bg_deletions;
> + dev->seq_number = cp->seq_number;
> +}
> +
> +static int yaffs2_wr_checkpt_dev(struct yaffs_dev *dev)
> +{
> + struct yaffs_checkpt_dev cp;
> + u32 n_bytes;
> + u32 n_blocks =
> + (dev->internal_end_block - dev->internal_start_block + 1);
> + int ok;
> +
> + /* Write device runtime values */
> + yaffs2_dev_to_checkpt_dev(&cp, dev);
> + cp.struct_type = sizeof(cp);
> +
> + ok = (yaffs2_checkpt_wr(dev, &cp, sizeof(cp)) == sizeof(cp));
> +
> + /* Write block info */
> + if (ok) {
> + n_bytes = n_blocks * sizeof(struct yaffs_block_info);
> + ok = (yaffs2_checkpt_wr(dev, dev->block_info, n_bytes) ==
> + n_bytes);
> + }
> +
> + /* Write chunk bits */
> + if (ok) {
> + n_bytes = n_blocks * dev->chunk_bit_stride;
> + ok = (yaffs2_checkpt_wr(dev, dev->chunk_bits, n_bytes) ==
> + n_bytes);
> + }
> + return ok ? 1 : 0;

Just return ok. You shouldn't need ? 1 : 0 everywhere.

> +}
> +
> +static int yaffs2_rd_checkpt_dev(struct yaffs_dev *dev)
> +{
> + struct yaffs_checkpt_dev cp;
> + u32 n_bytes;
> + u32 n_blocks =
> + (dev->internal_end_block - dev->internal_start_block + 1);
> + int ok;
> +
> + ok = (yaffs2_checkpt_rd(dev, &cp, sizeof(cp)) == sizeof(cp));
> + if (!ok)
> + return 0;
> +
> + if (cp.struct_type != sizeof(cp))
> + return 0;
> +
> + yaffs_checkpt_dev_to_dev(dev, &cp);
> +
> + n_bytes = n_blocks * sizeof(struct yaffs_block_info);
> +
> + ok = (yaffs2_checkpt_rd(dev, dev->block_info, n_bytes) == n_bytes);
> +
> + if (!ok)
> + return 0;
> + n_bytes = n_blocks * dev->chunk_bit_stride;
> +
> + ok = (yaffs2_checkpt_rd(dev, dev->chunk_bits, n_bytes) == n_bytes);
> +
> + return ok ? 1 : 0;
> +}
> +
> +static void yaffs2_obj_checkpt_obj(struct yaffs_checkpt_obj *cp,
> + struct yaffs_obj *obj)
> +{
> + cp->obj_id = obj->obj_id;
> + cp->parent_id = (obj->parent) ? obj->parent->obj_id : 0;
> + cp->hdr_chunk = obj->hdr_chunk;
> + cp->variant_type = obj->variant_type;
> + cp->deleted = obj->deleted;
> + cp->soft_del = obj->soft_del;
> + cp->unlinked = obj->unlinked;
> + cp->fake = obj->fake;
> + cp->rename_allowed = obj->rename_allowed;
> + cp->unlink_allowed = obj->unlink_allowed;
> + cp->serial = obj->serial;
> + cp->n_data_chunks = obj->n_data_chunks;
> +
> + if (obj->variant_type == YAFFS_OBJECT_TYPE_FILE)
> + cp->size_or_equiv_obj = obj->variant.file_variant.file_size;
> + else if (obj->variant_type == YAFFS_OBJECT_TYPE_HARDLINK)
> + cp->size_or_equiv_obj = obj->variant.hardlink_variant.equiv_id;
> +}
> +
> +static int taffs2_checkpt_obj_to_obj(struct yaffs_obj *obj,
> + struct yaffs_checkpt_obj *cp)
> +{
> + struct yaffs_obj *parent;
> +
> + if (obj->variant_type != cp->variant_type) {
> + yaffs_trace(YAFFS_TRACE_ERROR,
> + "Checkpoint read object %d type %d chunk %d does not match existing object type %d",
> + cp->obj_id, cp->variant_type, cp->hdr_chunk,
> + obj->variant_type);
> + return 0;
> + }
> +
> + obj->obj_id = cp->obj_id;
> +
> + if (cp->parent_id)
> + parent = yaffs_find_or_create_by_number(obj->my_dev,
> + cp->parent_id,
> + YAFFS_OBJECT_TYPE_DIRECTORY);
> + else
> + parent = NULL;
> +
> + if (parent) {
> + if (parent->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) {
> + yaffs_trace(YAFFS_TRACE_ALWAYS,
> + "Checkpoint read object %d parent %d type %d chunk %d Parent type, %d, not directory",
> + cp->obj_id, cp->parent_id,
> + cp->variant_type, cp->hdr_chunk,
> + parent->variant_type);
> + return 0;
> + }
> + yaffs_add_obj_to_dir(parent, obj);
> + }
> +
> + obj->hdr_chunk = cp->hdr_chunk;
> + obj->variant_type = cp->variant_type;
> + obj->deleted = cp->deleted;
> + obj->soft_del = cp->soft_del;
> + obj->unlinked = cp->unlinked;
> + obj->fake = cp->fake;
> + obj->rename_allowed = cp->rename_allowed;
> + obj->unlink_allowed = cp->unlink_allowed;
> + obj->serial = cp->serial;
> + obj->n_data_chunks = cp->n_data_chunks;
> +
> + if (obj->variant_type == YAFFS_OBJECT_TYPE_FILE)
> + obj->variant.file_variant.file_size = cp->size_or_equiv_obj;
> + else if (obj->variant_type == YAFFS_OBJECT_TYPE_HARDLINK)
> + obj->variant.hardlink_variant.equiv_id = cp->size_or_equiv_obj;
> +
> + if (obj->hdr_chunk > 0)
> + obj->lazy_loaded = 1;
> + return 1;
> +}
> +
> +static int yaffs2_checkpt_tnode_worker(struct yaffs_obj *in,
> + struct yaffs_tnode *tn, u32 level,
> + int chunk_offset)
> +{
> + int i;
> + struct yaffs_dev *dev = in->my_dev;
> + int ok = 1;
> +
> + if (tn) {

if (!tn)
return 1;
Then reduce the indentation :-).

> + if (level > 0) {
> +
> + for (i = 0; i < YAFFS_NTNODES_INTERNAL && ok; i++) {
> + if (tn->internal[i]) {
> + ok = yaffs2_checkpt_tnode_worker(in,
> + tn->internal[i],
> + level - 1,
> + (chunk_offset <<
> + YAFFS_TNODES_INTERNAL_BITS)
> + + i);
> + }
> + }
> + } else if (level == 0) {
> + u32 base_offset =
> + chunk_offset << YAFFS_TNODES_LEVEL0_BITS;
> + ok = (yaffs2_checkpt_wr
> + (dev, &base_offset,
> + sizeof(base_offset)) == sizeof(base_offset));
> + if (ok)
> + ok = (yaffs2_checkpt_wr
> + (dev, tn,
> + dev->tnode_size) == dev->tnode_size);
> + }
> + }
> +
> + return ok;
> +}
> +
> +static int yaffs2_wr_checkpt_tnodes(struct yaffs_obj *obj)
> +{
> + u32 end_marker = ~0;
> + int ok = 1;
> +
> + if (obj->variant_type == YAFFS_OBJECT_TYPE_FILE) {

Same here, reverse the if statement and reduce the indentation.

> + ok = yaffs2_checkpt_tnode_worker(obj,
> + obj->variant.file_variant.top,
> + obj->variant.file_variant.
> + top_level, 0);
> + if (ok)
> + ok = (yaffs2_checkpt_wr
> + (obj->my_dev, &end_marker,
> + sizeof(end_marker)) == sizeof(end_marker));
> + }
> +
> + return ok ? 1 : 0;
> +}
> +
> +static int yaffs2_rd_checkpt_tnodes(struct yaffs_obj *obj)
> +{
> + u32 base_chunk;
> + int ok = 1;
> + struct yaffs_dev *dev = obj->my_dev;
> + struct yaffs_file_var *file_stuct_ptr = &obj->variant.file_variant;
> + struct yaffs_tnode *tn;
> + int nread = 0;
> +
> + ok = (yaffs2_checkpt_rd(dev, &base_chunk, sizeof(base_chunk)) ==
> + sizeof(base_chunk));
> +
> + while (ok && (~base_chunk)) {
> + nread++;
> + /* Read level 0 tnode */
> +
> + tn = yaffs_get_tnode(dev);
> + if (tn)
> + ok = (yaffs2_checkpt_rd(dev, tn, dev->tnode_size) ==
> + dev->tnode_size);
> + else
> + ok = 0;
> +
> + if (tn && ok)
> + ok = yaffs_add_find_tnode_0(dev,
> + file_stuct_ptr,
> + base_chunk, tn) ? 1 : 0;
> +
> + if (ok)
> + ok = (yaffs2_checkpt_rd
> + (dev, &base_chunk,
> + sizeof(base_chunk)) == sizeof(base_chunk));
> + }
> +
> + yaffs_trace(YAFFS_TRACE_CHECKPOINT,
> + "Checkpoint read tnodes %d records, last %d. ok %d",
> + nread, base_chunk, ok);
> +
> + return ok ? 1 : 0;
> +}
> +
> +static int yaffs2_wr_checkpt_objs(struct yaffs_dev *dev)
> +{
> + struct yaffs_obj *obj;
> + struct yaffs_checkpt_obj cp;
> + int i;
> + int ok = 1;
> + struct list_head *lh;
> +
> + /* Iterate through the objects in each hash entry,
> + * dumping them to the checkpointing stream.
> + */
> +
> + for (i = 0; ok && i < YAFFS_NOBJECT_BUCKETS; i++) {
> + list_for_each(lh, &dev->obj_bucket[i].list) {
> + obj = list_entry(lh, struct yaffs_obj, hash_link);

list_for_each_entry(lh, &dev->obj_bucket[i].list, hash_link)

> + if (!obj->defered_free) {
> + yaffs2_obj_checkpt_obj(&cp, obj);
> + cp.struct_type = sizeof(cp);
> +
> + yaffs_trace(YAFFS_TRACE_CHECKPOINT,
> + "Checkpoint write object %d parent %d type %d chunk %d obj addr %p",
> + cp.obj_id, cp.parent_id,
> + cp.variant_type, cp.hdr_chunk, obj);
> +
> + ok = (yaffs2_checkpt_wr(dev, &cp,
> + sizeof(cp)) == sizeof(cp));
> +
> + if (ok &&
> + obj->variant_type ==
> + YAFFS_OBJECT_TYPE_FILE)
> + ok = yaffs2_wr_checkpt_tnodes(obj);
> + }
> + }
> + }
> +
> + /* Dump end of list */
> + memset(&cp, 0xFF, sizeof(struct yaffs_checkpt_obj));
> + cp.struct_type = sizeof(cp);
> +
> + if (ok)
> + ok = (yaffs2_checkpt_wr(dev, &cp, sizeof(cp)) == sizeof(cp));
> +
> + return ok ? 1 : 0;
> +}
> +
> +static int yaffs2_rd_checkpt_objs(struct yaffs_dev *dev)
> +{
> + struct yaffs_obj *obj;
> + struct yaffs_checkpt_obj cp;
> + int ok = 1;
> + int done = 0;
> + struct yaffs_obj *hard_list = NULL;
> +
> + while (ok && !done) {
> + ok = (yaffs2_checkpt_rd(dev, &cp, sizeof(cp)) == sizeof(cp));
> + if (cp.struct_type != sizeof(cp)) {
> + yaffs_trace(YAFFS_TRACE_CHECKPOINT,
> + "struct size %d instead of %d ok %d",
> + cp.struct_type, (int)sizeof(cp), ok);
> + ok = 0;
> + }
> +
> + yaffs_trace(YAFFS_TRACE_CHECKPOINT,
> + "Checkpoint read object %d parent %d type %d chunk %d ",
> + cp.obj_id, cp.parent_id, cp.variant_type,
> + cp.hdr_chunk);
> +
> + if (ok && cp.obj_id == ~0) {
> + done = 1;
> + } else if (ok) {
> + obj =
> + yaffs_find_or_create_by_number(dev, cp.obj_id,
> + cp.variant_type);
> + if (obj) {
> + ok = taffs2_checkpt_obj_to_obj(obj, &cp);
> + if (!ok)
> + break;
> + if (obj->variant_type ==
> + YAFFS_OBJECT_TYPE_FILE) {
> + ok = yaffs2_rd_checkpt_tnodes(obj);
> + } else if (obj->variant_type ==
> + YAFFS_OBJECT_TYPE_HARDLINK) {
> + obj->hard_links.next =
> + (struct list_head *)hard_list;
> + hard_list = obj;
> + }
> + } else {
> + ok = 0;
> + }
> + }
> + }
> +
> + if (ok)
> + yaffs_link_fixup(dev, hard_list);
> +
> + return ok ? 1 : 0;
> +}
> +
> +static int yaffs2_wr_checkpt_sum(struct yaffs_dev *dev)
> +{
> + u32 checkpt_sum;
> + int ok;
> +
> + yaffs2_get_checkpt_sum(dev, &checkpt_sum);
> +
> + ok = (yaffs2_checkpt_wr(dev, &checkpt_sum, sizeof(checkpt_sum)) ==
> + sizeof(checkpt_sum));
> +
> + if (!ok)
> + return 0;
> +
> + return 1;

return ok; ?

> +}
> +
> +static int yaffs2_rd_checkpt_sum(struct yaffs_dev *dev)
> +{
> + u32 checkpt_sum0;
> + u32 checkpt_sum1;
> + int ok;
> +
> + yaffs2_get_checkpt_sum(dev, &checkpt_sum0);
> +
> + ok = (yaffs2_checkpt_rd(dev, &checkpt_sum1, sizeof(checkpt_sum1)) ==
> + sizeof(checkpt_sum1));
> +
> + if (!ok)
> + return 0;
> +
> + if (checkpt_sum0 != checkpt_sum1)
> + return 0;
> +
> + return 1;
> +}
> +
> +static int yaffs2_wr_checkpt_data(struct yaffs_dev *dev)
> +{
> + int ok = 1;
> +
> + if (!yaffs2_checkpt_required(dev)) {
> + yaffs_trace(YAFFS_TRACE_CHECKPOINT,
> + "skipping checkpoint write");
> + ok = 0;
> + }
> +
> + if (ok)
> + ok = yaffs2_checkpt_open(dev, 1);
> +
> + if (ok) {
> + yaffs_trace(YAFFS_TRACE_CHECKPOINT,
> + "write checkpoint validity");
> + ok = yaffs2_wr_checkpt_validity_marker(dev, 1);
> + }
> + if (ok) {
> + yaffs_trace(YAFFS_TRACE_CHECKPOINT,
> + "write checkpoint device");
> + ok = yaffs2_wr_checkpt_dev(dev);
> + }
> + if (ok) {
> + yaffs_trace(YAFFS_TRACE_CHECKPOINT,
> + "write checkpoint objects");
> + ok = yaffs2_wr_checkpt_objs(dev);
> + }
> + if (ok) {
> + yaffs_trace(YAFFS_TRACE_CHECKPOINT,
> + "write checkpoint validity");
> + ok = yaffs2_wr_checkpt_validity_marker(dev, 0);
> + }
> +
> + if (ok)
> + ok = yaffs2_wr_checkpt_sum(dev);
> +
> + if (!yaffs_checkpt_close(dev))
> + ok = 0;
> +
> + if (ok)
> + dev->is_checkpointed = 1;
> + else
> + dev->is_checkpointed = 0;

dev->is_checkpointed = ok;

> +
> + return dev->is_checkpointed;
> +}
> +
> +static int yaffs2_rd_checkpt_data(struct yaffs_dev *dev)
> +{
> + int ok = 1;
> +
> + if (!dev->param.is_yaffs2)
> + ok = 0;
> +
> + if (ok && dev->param.skip_checkpt_rd) {
> + yaffs_trace(YAFFS_TRACE_CHECKPOINT,
> + "skipping checkpoint read");
> + ok = 0;
> + }
> +
> + if (ok)
> + ok = yaffs2_checkpt_open(dev, 0); /* open for read */
> +
> + if (ok) {
> + yaffs_trace(YAFFS_TRACE_CHECKPOINT,
> + "read checkpoint validity");
> + ok = yaffs2_rd_checkpt_validity_marker(dev, 1);
> + }
> + if (ok) {
> + yaffs_trace(YAFFS_TRACE_CHECKPOINT,
> + "read checkpoint device");
> + ok = yaffs2_rd_checkpt_dev(dev);
> + }
> + if (ok) {
> + yaffs_trace(YAFFS_TRACE_CHECKPOINT,
> + "read checkpoint objects");
> + ok = yaffs2_rd_checkpt_objs(dev);
> + }
> + if (ok) {
> + yaffs_trace(YAFFS_TRACE_CHECKPOINT,
> + "read checkpoint validity");
> + ok = yaffs2_rd_checkpt_validity_marker(dev, 0);
> + }
> +
> + if (ok) {
> + ok = yaffs2_rd_checkpt_sum(dev);
> + yaffs_trace(YAFFS_TRACE_CHECKPOINT,
> + "read checkpoint checksum %d", ok);
> + }
> +
> + if (!yaffs_checkpt_close(dev))
> + ok = 0;
> +
> + if (ok)
> + dev->is_checkpointed = 1;
> + else
> + dev->is_checkpointed = 0;

dev->is_checkpointed = ok;

> +
> + return ok ? 1 : 0;
> +}
> +
> +void yaffs2_checkpt_invalidate(struct yaffs_dev *dev)
> +{
> + if (dev->is_checkpointed || dev->blocks_in_checkpt > 0) {
> + dev->is_checkpointed = 0;
> + yaffs2_checkpt_invalidate_stream(dev);
> + }
> + if (dev->param.sb_dirty_fn)
> + dev->param.sb_dirty_fn(dev);
> +}
> +
> +int yaffs_checkpoint_save(struct yaffs_dev *dev)
> +{
> + yaffs_trace(YAFFS_TRACE_CHECKPOINT,
> + "save entry: is_checkpointed %d",
> + dev->is_checkpointed);
> +
> + yaffs_verify_objects(dev);
> + yaffs_verify_blocks(dev);
> + yaffs_verify_free_chunks(dev);
> +
> + if (!dev->is_checkpointed) {
> + yaffs2_checkpt_invalidate(dev);
> + yaffs2_wr_checkpt_data(dev);
> + }
> +
> + yaffs_trace(YAFFS_TRACE_CHECKPOINT | YAFFS_TRACE_MOUNT,
> + "save exit: is_checkpointed %d",
> + dev->is_checkpointed);
> +
> + return dev->is_checkpointed;
> +}
> +
> +int yaffs2_checkpt_restore(struct yaffs_dev *dev)
> +{
> + int retval;
> +
> + yaffs_trace(YAFFS_TRACE_CHECKPOINT,
> + "restore entry: is_checkpointed %d",
> + dev->is_checkpointed);
> +
> + retval = yaffs2_rd_checkpt_data(dev);
> +
> + if (dev->is_checkpointed) {
> + yaffs_verify_objects(dev);
> + yaffs_verify_blocks(dev);
> + yaffs_verify_free_chunks(dev);
> + }
> +
> + yaffs_trace(YAFFS_TRACE_CHECKPOINT,
> + "restore exit: is_checkpointed %d",
> + dev->is_checkpointed);
> +
> + return retval;
> +}
> +
> +int yaffs2_handle_hole(struct yaffs_obj *obj, loff_t new_size)
> +{
> + /* if new_size > old_file_size.
> + * We're going to be writing a hole.
> + * If the hole is small then write zeros otherwise write a start
> + * of hole marker.
> + */
> + loff_t old_file_size;
> + int increase;
> + int small_hole;
> + int result = YAFFS_OK;
> + struct yaffs_dev *dev = NULL;
> + u8 *local_buffer = NULL;
> + int small_increase_ok = 0;
> +
> + if (!obj)
> + return YAFFS_FAIL;
> +
> + if (obj->variant_type != YAFFS_OBJECT_TYPE_FILE)
> + return YAFFS_FAIL;
> +
> + dev = obj->my_dev;
> +
> + /* Bail out if not yaffs2 mode */
> + if (!dev->param.is_yaffs2)
> + return YAFFS_OK;
> +
> + old_file_size = obj->variant.file_variant.file_size;
> +
> + if (new_size <= old_file_size)
> + return YAFFS_OK;
> +
> + increase = new_size - old_file_size;
> +
> + if (increase < YAFFS_SMALL_HOLE_THRESHOLD * dev->data_bytes_per_chunk &&
> + yaffs_check_alloc_available(dev, YAFFS_SMALL_HOLE_THRESHOLD + 1))
> + small_hole = 1;
> + else
> + small_hole = 0;
> +
> + if (small_hole)
> + local_buffer = yaffs_get_temp_buffer(dev, __LINE__);

small_hole only gets used for this test? Remove the small_hole variable
and make the if happen directly.

> +
> + if (local_buffer) {
> + /* fill hole with zero bytes */
> + int pos = old_file_size;
> + int this_write;
> + int written;
> + memset(local_buffer, 0, dev->data_bytes_per_chunk);
> + small_increase_ok = 1;
> +
> + while (increase > 0 && small_increase_ok) {
> + this_write = increase;
> + if (this_write > dev->data_bytes_per_chunk)
> + this_write = dev->data_bytes_per_chunk;
> + written =
> + yaffs_do_file_wr(obj, local_buffer, pos, this_write,
> + 0);
> + if (written == this_write) {
> + pos += this_write;
> + increase -= this_write;
> + } else {
> + small_increase_ok = 0;
> + }
> + }
> +
> + yaffs_release_temp_buffer(dev, local_buffer, __LINE__);
> +
> + /* If out of space then reverse any chunks we've added */
> + if (!small_increase_ok)
> + yaffs_resize_file_down(obj, old_file_size);
> + }
> +
> + if (!small_increase_ok &&
> + obj->parent &&
> + obj->parent->obj_id != YAFFS_OBJECTID_UNLINKED &&
> + obj->parent->obj_id != YAFFS_OBJECTID_DELETED) {
> + /* Write a hole start header with the old file size */
> + yaffs_update_oh(obj, NULL, 0, 1, 0, NULL);
> + }
> +
> + return result;
> +}
> +
> +struct yaffs_block_index {
> + int seq;
> + int block;
> +};
> +
> +static int yaffs2_ybicmp(const void *a, const void *b)
> +{
> + int aseq = ((struct yaffs_block_index *)a)->seq;
> + int bseq = ((struct yaffs_block_index *)b)->seq;
> + int ablock = ((struct yaffs_block_index *)a)->block;
> + int bblock = ((struct yaffs_block_index *)b)->block;
> +
> + if (aseq == bseq)
> + return ablock - bblock;
> + else
> + return aseq - bseq;
> +}
> +
> +static inline int yaffs2_scan_chunk(struct yaffs_dev *dev,
> + struct yaffs_block_info *bi,
> + int blk, int chunk_in_block,
> + int *found_chunks,
> + u8 *chunk_data,
> + struct yaffs_obj **hard_list)
> +{
> + struct yaffs_obj_hdr *oh;
> + struct yaffs_obj *in;
> + struct yaffs_obj *parent;
> + int equiv_id;
> + int file_size;
> + int is_shrink;
> + int is_unlinked;
> + struct yaffs_ext_tags tags;
> + int result;
> + int alloc_failed = 0;
> + int chunk = blk * dev->param.chunks_per_block + chunk_in_block;
> + struct yaffs_file_var *file_var;
> + struct yaffs_hardlink_var *hl_var;
> + struct yaffs_symlink_var *sl_var;
> +
> + result = yaffs_rd_chunk_tags_nand(dev, chunk, NULL, &tags);
> +
> + /* Let's have a good look at this chunk... */
> +
> + if (!tags.chunk_used) {
> + /* An unassigned chunk in the block.
> + * If there are used chunks after this one, then
> + * it is a chunk that was skipped due to failing
> + * the erased check. Just skip it so that it can
> + * be deleted.
> + * But, more typically, We get here when this is
> + * an unallocated chunk and his means that
> + * either the block is empty or this is the one
> + * being allocated from
> + */
> +
> + if (*found_chunks) {
> + /* This is a chunk that was skipped due
> + * to failing the erased check */
> + } else if (chunk_in_block == 0) {
> + /* We're looking at the first chunk in
> + * the block so the block is unused */
> + bi->block_state = YAFFS_BLOCK_STATE_EMPTY;
> + dev->n_erased_blocks++;
> + } else {
> + if (bi->block_state == YAFFS_BLOCK_STATE_NEEDS_SCANNING
> + || bi->block_state == YAFFS_BLOCK_STATE_ALLOCATING) {
> + if (dev->seq_number == bi->seq_number) {
> + /* Allocating from this block*/
> + yaffs_trace(YAFFS_TRACE_SCAN,
> + " Allocating from %d %d",
> + blk, chunk_in_block);
> +
> + bi->block_state =
> + YAFFS_BLOCK_STATE_ALLOCATING;
> + dev->alloc_block = blk;
> + dev->alloc_page = chunk_in_block;
> + dev->alloc_block_finder = blk;
> + } else {
> + /* This is a partially written block
> + * that is not the current
> + * allocation block.
> + */
> + yaffs_trace(YAFFS_TRACE_SCAN,
> + "Partially written block %d detected. gc will fix this.",
> + blk);
> + }
> + }
> + }
> +
> + dev->n_free_chunks++;
> +
> + } else if (tags.ecc_result ==
> + YAFFS_ECC_RESULT_UNFIXED) {
> + yaffs_trace(YAFFS_TRACE_SCAN,
> + " Unfixed ECC in chunk(%d:%d), chunk ignored",
> + blk, chunk_in_block);
> + dev->n_free_chunks++;
> + } else if (tags.obj_id > YAFFS_MAX_OBJECT_ID ||
> + tags.chunk_id > YAFFS_MAX_CHUNK_ID ||
> + (tags.chunk_id > 0 &&
> + tags.n_bytes > dev->data_bytes_per_chunk) ||
> + tags.seq_number != bi->seq_number) {
> + yaffs_trace(YAFFS_TRACE_SCAN,
> + "Chunk (%d:%d) with bad tags:obj = %d, chunk_id = %d, n_bytes = %d, ignored",
> + blk, chunk_in_block, tags.obj_id,
> + tags.chunk_id, tags.n_bytes);
> + dev->n_free_chunks++;
> + } else if (tags.chunk_id > 0) {
> + /* chunk_id > 0 so it is a data chunk... */
> + unsigned int endpos;
> + u32 chunk_base = (tags.chunk_id - 1) *
> + dev->data_bytes_per_chunk;
> +
> + *found_chunks = 1;
> +
> + yaffs_set_chunk_bit(dev, blk, chunk_in_block);
> + bi->pages_in_use++;
> +
> + in = yaffs_find_or_create_by_number(dev,
> + tags.obj_id,
> + YAFFS_OBJECT_TYPE_FILE);
> + if (!in)
> + /* Out of memory */
> + alloc_failed = 1;

Bail: goto alloc_failed;

> +
> + if (in &&
> + in->variant_type == YAFFS_OBJECT_TYPE_FILE &&
> + chunk_base < in->variant.file_variant.shrink_size) {
> + /* This has not been invalidated by
> + * a resize */
> + if (!yaffs_put_chunk_in_file(in, tags.chunk_id,
> + chunk, -1))
> + alloc_failed = 1;
> +
> + /* File size is calculated by looking at
> + * the data chunks if we have not
> + * seen an object header yet.
> + * Stop this practice once we find an
> + * object header.
> + */
> + endpos = chunk_base + tags.n_bytes;
> +
> + if (!in->valid &&
> + in->variant.file_variant.scanned_size < endpos) {
> + in->variant.file_variant.
> + scanned_size = endpos;
> + in->variant.file_variant.
> + file_size = endpos;
> + }
> + } else if (in) {
> + /* This chunk has been invalidated by a
> + * resize, or a past file deletion
> + * so delete the chunk*/
> + yaffs_chunk_del(dev, chunk, 1, __LINE__);
> + }
> + } else {
> + /* chunk_id == 0, so it is an ObjectHeader.
> + * Thus, we read in the object header and make
> + * the object
> + */
> + *found_chunks = 1;
> +
> + yaffs_set_chunk_bit(dev, blk, chunk_in_block);
> + bi->pages_in_use++;
> +
> + oh = NULL;
> + in = NULL;
> +
> + if (tags.extra_available) {
> + in = yaffs_find_or_create_by_number(dev,
> + tags.obj_id,
> + tags.extra_obj_type);
> + if (!in)
> + alloc_failed = 1;
> + }
> +
> + if (!in ||
> + (!in->valid && dev->param.disable_lazy_load)
> + || tags.extra_shadows ||
> + (!in->valid && (tags.obj_id ==
> + YAFFS_OBJECTID_ROOT
> + || tags.obj_id ==
> + YAFFS_OBJECTID_LOSTNFOUND))) {

My brain hurts :-).

> +
> + /* If we don't have valid info then we
> + * need to read the chunk
> + * TODO In future we can probably defer
> + * reading the chunk and living with
> + * invalid data until needed.
> + */
> +
> + result = yaffs_rd_chunk_tags_nand(dev,
> + chunk,
> + chunk_data,
> + NULL);
> +
> + oh = (struct yaffs_obj_hdr *)chunk_data;
> +
> + if (dev->param.inband_tags) {
> + /* Fix up the header if they got
> + * corrupted by inband tags */
> + oh->shadows_obj =
> + oh->inband_shadowed_obj_id;
> + oh->is_shrink =
> + oh->inband_is_shrink;
> + }
> +
> + if (!in) {
> + in = yaffs_find_or_create_by_number(dev,
> + tags.obj_id, oh->type);
> + if (!in)
> + alloc_failed = 1;
> + }
> + }
> +
> + if (!in) {
> + /* TODO Hoosterman we have a problem! */
> + yaffs_trace(YAFFS_TRACE_ERROR,
> + "yaffs tragedy: Could not make object for object %d at chunk %d during scan",
> + tags.obj_id, chunk);
> + return YAFFS_FAIL;
> + }
> +
> + if (in->valid) {
> + /* We have already filled this one.
> + * We have a duplicate that will be
> + * discarded, but we first have to suck
> + * out resize info if it is a file.
> + */
> + if ((in->variant_type == YAFFS_OBJECT_TYPE_FILE) &&
> + ((oh && oh->type == YAFFS_OBJECT_TYPE_FILE) ||
> + (tags.extra_available &&
> + tags.extra_obj_type == YAFFS_OBJECT_TYPE_FILE)
> + )) {
> + u32 this_size = (oh) ?
> + oh->file_size :
> + tags.extra_length;
> + u32 parent_obj_id = (oh) ?
> + oh->parent_obj_id :
> + tags.extra_parent_id;
> +
> + is_shrink = (oh) ?
> + oh->is_shrink :
> + tags.extra_is_shrink;
> +
> + /* If it is deleted (unlinked
> + * at start also means deleted)
> + * we treat the file size as
> + * being zeroed at this point.
> + */
> + if (parent_obj_id == YAFFS_OBJECTID_DELETED ||
> + parent_obj_id == YAFFS_OBJECTID_UNLINKED) {
> + this_size = 0;
> + is_shrink = 1;
> + }
> +
> + if (is_shrink &&
> + in->variant.file_variant.shrink_size >
> + this_size)
> + in->variant.file_variant.shrink_size =
> + this_size;
> +
> + if (is_shrink)
> + bi->has_shrink_hdr = 1;
> + }
> + /* Use existing - destroy this one. */
> + yaffs_chunk_del(dev, chunk, 1, __LINE__);
> + }
> +
> + if (!in->valid && in->variant_type !=
> + (oh ? oh->type : tags.extra_obj_type))
> + yaffs_trace(YAFFS_TRACE_ERROR,
> + "yaffs tragedy: Bad object type, %d != %d, for object %d at chunk %d during scan",
> + oh ? oh->type : tags.extra_obj_type,
> + in->variant_type, tags.obj_id,
> + chunk);
> +
> + if (!in->valid &&
> + (tags.obj_id == YAFFS_OBJECTID_ROOT ||
> + tags.obj_id == YAFFS_OBJECTID_LOSTNFOUND)) {
> + /* We only load some info, don't fiddle
> + * with directory structure */
> + in->valid = 1;
> +
> + if (oh) {
> + in->yst_mode = oh->yst_mode;
> + yaffs_load_attribs(in, oh);
> + in->lazy_loaded = 0;
> + } else {
> + in->lazy_loaded = 1;
> + }
> + in->hdr_chunk = chunk;
> +
> + } else if (!in->valid) {
> + /* we need to load this info */
> + in->valid = 1;
> + in->hdr_chunk = chunk;
> + if (oh) {
> + in->variant_type = oh->type;
> + in->yst_mode = oh->yst_mode;
> + yaffs_load_attribs(in, oh);
> +
> + if (oh->shadows_obj > 0)
> + yaffs_handle_shadowed_obj(dev,
> + oh->shadows_obj, 1);
> +
> + yaffs_set_obj_name_from_oh(in, oh);
> + parent = yaffs_find_or_create_by_number(dev,
> + oh->parent_obj_id,
> + YAFFS_OBJECT_TYPE_DIRECTORY);
> + file_size = oh->file_size;
> + is_shrink = oh->is_shrink;
> + equiv_id = oh->equiv_id;
> + } else {
> + in->variant_type = tags.extra_obj_type;
> + parent = yaffs_find_or_create_by_number(dev,
> + tags.extra_parent_id,
> + YAFFS_OBJECT_TYPE_DIRECTORY);
> + file_size = tags.extra_length;
> + is_shrink = tags.extra_is_shrink;
> + equiv_id = tags.extra_equiv_id;
> + in->lazy_loaded = 1;
> + }
> + in->dirty = 0;
> +
> + if (!parent)
> + alloc_failed = 1;
> +
> + /* directory stuff...
> + * hook up to parent
> + */
> +
> + if (parent &&
> + parent->variant_type == YAFFS_OBJECT_TYPE_UNKNOWN) {
> + /* Set up as a directory */
> + parent->variant_type =
> + YAFFS_OBJECT_TYPE_DIRECTORY;
> + INIT_LIST_HEAD(&parent->
> + variant.dir_variant.children);
> + } else if (!parent ||
> + parent->variant_type !=
> + YAFFS_OBJECT_TYPE_DIRECTORY) {
> + /* Hoosterman, another problem....
> + * Trying to use a non-directory as a directory
> + */
> +
> + yaffs_trace(YAFFS_TRACE_ERROR,
> + "yaffs tragedy: attempting to use non-directory as a directory in scan. Put in lost+found."
> + );
> + parent = dev->lost_n_found;
> + }
> + yaffs_add_obj_to_dir(parent, in);
> +
> + is_unlinked = (parent == dev->del_dir) ||
> + (parent == dev->unlinked_dir);
> +
> + if (is_shrink)
> + /* Mark the block */
> + bi->has_shrink_hdr = 1;
> +
> + /* Note re hardlinks.
> + * Since we might scan a hardlink before its equivalent
> + * object is scanned we put them all in a list.
> + * After scanning is complete, we should have all the
> + * objects, so we run through this list and fix up all
> + * the chains.
> + */
> +
> + switch (in->variant_type) {
> + case YAFFS_OBJECT_TYPE_UNKNOWN:
> + /* Todo got a problem */
> + break;
> + case YAFFS_OBJECT_TYPE_FILE:
> + file_var = &in->variant.file_variant;
> + if (file_var->scanned_size < file_size) {
> + /* This covers the case where the file
> + * size is greater than the data held.
> + * This will happen if the file is
> + * resized to be larger than its
> + * current data extents.
> + */
> + file_var->file_size = file_size;
> + file_var->scanned_size = file_size;
> + }
> +
> + if (file_var->shrink_size > file_size)
> + file_var->shrink_size = file_size;
> +
> + break;
> + case YAFFS_OBJECT_TYPE_HARDLINK:
> + hl_var = &in->variant.hardlink_variant;
> + if (!is_unlinked) {
> + hl_var->equiv_id = equiv_id;
> + in->hard_links.next =
> + (struct list_head *) *hard_list;

List trickery?

> + *hard_list = in;
> + }
> + break;
> + case YAFFS_OBJECT_TYPE_DIRECTORY:
> + /* Do nothing */
> + break;
> + case YAFFS_OBJECT_TYPE_SPECIAL:
> + /* Do nothing */
> + break;
> + case YAFFS_OBJECT_TYPE_SYMLINK:
> + sl_var = &in->variant.symlink_variant;
> + if (oh) {
> + sl_var->alias =
> + yaffs_clone_str(oh->alias);
> + if (!sl_var->alias)
> + alloc_failed = 1;
> + }
> + break;
> + }
> + }
> + }
> + return alloc_failed ? YAFFS_FAIL : YAFFS_OK;
> +}
> +
> +int yaffs2_scan_backwards(struct yaffs_dev *dev)
> +{
> + int blk;
> + int block_iter;
> + int start_iter;
> + int end_iter;
> + int n_to_scan = 0;
> + enum yaffs_block_state state;
> + int c;
> + int deleted;
> + struct yaffs_obj *hard_list = NULL;
> + struct yaffs_block_info *bi;
> + u32 seq_number;
> + int n_blocks = dev->internal_end_block - dev->internal_start_block + 1;
> + u8 *chunk_data;
> + int found_chunks;
> + int alloc_failed = 0;
> + struct yaffs_block_index *block_index = NULL;
> + int alt_block_index = 0;
> +
> + yaffs_trace(YAFFS_TRACE_SCAN,
> + "yaffs2_scan_backwards starts intstartblk %d intendblk %d...",
> + dev->internal_start_block, dev->internal_end_block);
> +
> + dev->seq_number = YAFFS_LOWEST_SEQUENCE_NUMBER;
> +
> + block_index = kmalloc(n_blocks * sizeof(struct yaffs_block_index),
> + GFP_NOFS);
> +
> + if (!block_index) {
> + block_index =
> + vmalloc(n_blocks * sizeof(struct yaffs_block_index));
> + alt_block_index = 1;

How big is this alloc? Does it make more sense to just always use
vmalloc and simplify the code?

> + }
> +
> + if (!block_index) {
> + yaffs_trace(YAFFS_TRACE_SCAN,
> + "yaffs2_scan_backwards() could not allocate block index!"
> + );
> + return YAFFS_FAIL;
> + }
> +
> + dev->blocks_in_checkpt = 0;
> +
> + chunk_data = yaffs_get_temp_buffer(dev, __LINE__);
> +
> + /* Scan all the blocks to determine their state */
> + bi = dev->block_info;
> + for (blk = dev->internal_start_block; blk <= dev->internal_end_block;
> + blk++) {
> + yaffs_clear_chunk_bits(dev, blk);
> + bi->pages_in_use = 0;
> + bi->soft_del_pages = 0;
> +
> + yaffs_query_init_block_state(dev, blk, &state, &seq_number);
> +
> + bi->block_state = state;
> + bi->seq_number = seq_number;
> +
> + if (bi->seq_number == YAFFS_SEQUENCE_CHECKPOINT_DATA)
> + bi->block_state = YAFFS_BLOCK_STATE_CHECKPOINT;
> + if (bi->seq_number == YAFFS_SEQUENCE_BAD_BLOCK)
> + bi->block_state = YAFFS_BLOCK_STATE_DEAD;
> +
> + yaffs_trace(YAFFS_TRACE_SCAN_DEBUG,
> + "Block scanning block %d state %d seq %d",
> + blk, bi->block_state, seq_number);
> +
> + if (bi->block_state == YAFFS_BLOCK_STATE_CHECKPOINT) {
> + dev->blocks_in_checkpt++;
> +
> + } else if (bi->block_state == YAFFS_BLOCK_STATE_DEAD) {
> + yaffs_trace(YAFFS_TRACE_BAD_BLOCKS,
> + "block %d is bad", blk);
> + } else if (bi->block_state == YAFFS_BLOCK_STATE_EMPTY) {
> + yaffs_trace(YAFFS_TRACE_SCAN_DEBUG, "Block empty ");
> + dev->n_erased_blocks++;
> + dev->n_free_chunks += dev->param.chunks_per_block;
> + } else if (bi->block_state ==
> + YAFFS_BLOCK_STATE_NEEDS_SCANNING) {
> + /* Determine the highest sequence number */
> + if (seq_number >= YAFFS_LOWEST_SEQUENCE_NUMBER &&
> + seq_number < YAFFS_HIGHEST_SEQUENCE_NUMBER) {
> + block_index[n_to_scan].seq = seq_number;
> + block_index[n_to_scan].block = blk;
> + n_to_scan++;
> + if (seq_number >= dev->seq_number)
> + dev->seq_number = seq_number;
> + } else {
> + /* TODO: Nasty sequence number! */
> + yaffs_trace(YAFFS_TRACE_SCAN,
> + "Block scanning block %d has bad sequence number %d",
> + blk, seq_number);
> + }
> + }
> + bi++;
> + }
> +
> + yaffs_trace(YAFFS_TRACE_SCAN, "%d blocks to be sorted...", n_to_scan);
> +
> + cond_resched();
> +
> + /* Sort the blocks by sequence number */
> + sort(block_index, n_to_scan, sizeof(struct yaffs_block_index),
> + yaffs2_ybicmp, NULL);
> +
> + cond_resched();
> +
> + yaffs_trace(YAFFS_TRACE_SCAN, "...done");
> +
> + /* Now scan the blocks looking at the data. */
> + start_iter = 0;
> + end_iter = n_to_scan - 1;
> + yaffs_trace(YAFFS_TRACE_SCAN_DEBUG, "%d blocks to scan", n_to_scan);
> +
> + /* For each block.... backwards */
> + for (block_iter = end_iter; !alloc_failed && block_iter >= start_iter;
> + block_iter--) {
> + /* Cooperative multitasking! This loop can run for so
> + long that watchdog timers expire. */
> + cond_resched();

Can parts of it be moved to a tasklet, kernel thread, etc?

> +
> + /* get the block to scan in the correct order */
> + blk = block_index[block_iter].block;
> + bi = yaffs_get_block_info(dev, blk);
> + deleted = 0;
> +
> + /* For each chunk in each block that needs scanning.... */
> + found_chunks = 0;
> + for (c = dev->param.chunks_per_block - 1;
> + !alloc_failed && c >= 0 &&
> + (bi->block_state == YAFFS_BLOCK_STATE_NEEDS_SCANNING ||
> + 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)
> + alloc_failed = 1;
> + }
> +
> + if (bi->block_state == YAFFS_BLOCK_STATE_NEEDS_SCANNING) {
> + /* If we got this far while scanning, then the block
> + * is fully allocated. */
> + bi->block_state = YAFFS_BLOCK_STATE_FULL;
> + }
> +
> + /* Now let's see if it was dirty */
> + if (bi->pages_in_use == 0 &&
> + !bi->has_shrink_hdr &&
> + bi->block_state == YAFFS_BLOCK_STATE_FULL) {
> + yaffs_block_became_dirty(dev, blk);
> + }
> + }
> +
> + yaffs_skip_rest_of_block(dev);
> +
> + if (alt_block_index)
> + vfree(block_index);
> + else
> + kfree(block_index);
> +
> + /* Ok, we've done all the scanning.
> + * Fix up the hard link chains.
> + * We have scanned all the objects, now it's time to add these
> + * hardlinks.
> + */
> + yaffs_link_fixup(dev, hard_list);
> +
> + yaffs_release_temp_buffer(dev, chunk_data, __LINE__);
> +
> + if (alloc_failed)
> + return YAFFS_FAIL;
> +
> + yaffs_trace(YAFFS_TRACE_SCAN, "yaffs2_scan_backwards ends");
> +
> + return YAFFS_OK;
> +}
> diff --git a/fs/yaffs2/yaffs_yaffs2.h b/fs/yaffs2/yaffs_yaffs2.h
> new file mode 100644
> index 0000000..e1a9287
> --- /dev/null
> +++ b/fs/yaffs2/yaffs_yaffs2.h
> @@ -0,0 +1,39 @@
> +/*
> + * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
> + *
> + * Copyright (C) 2002-2010 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_YAFFS2_H__
> +#define __YAFFS_YAFFS2_H__
> +
> +#include "yaffs_guts.h"
> +
> +void yaffs_calc_oldest_dirty_seq(struct yaffs_dev *dev);
> +void yaffs2_find_oldest_dirty_seq(struct yaffs_dev *dev);
> +void yaffs2_clear_oldest_dirty_seq(struct yaffs_dev *dev,
> + struct yaffs_block_info *bi);
> +void yaffs2_update_oldest_dirty_seq(struct yaffs_dev *dev, unsigned block_no,
> + struct yaffs_block_info *bi);
> +int yaffs_block_ok_for_gc(struct yaffs_dev *dev, struct yaffs_block_info *bi);
> +u32 yaffs2_find_refresh_block(struct yaffs_dev *dev);
> +int yaffs2_checkpt_required(struct yaffs_dev *dev);
> +int yaffs_calc_checkpt_blocks_required(struct yaffs_dev *dev);
> +
> +void yaffs2_checkpt_invalidate(struct yaffs_dev *dev);
> +int yaffs2_checkpt_save(struct yaffs_dev *dev);
> +int yaffs2_checkpt_restore(struct yaffs_dev *dev);
> +
> +int yaffs2_handle_hole(struct yaffs_obj *obj, loff_t new_size);
> +int yaffs2_scan_backwards(struct yaffs_dev *dev);
> +
> +#endif


--
Bluewater Systems Ltd - ARM Technology Solution Centre

Ryan Mallon 5 Amuri Park, 404 Barbadoes St
ryan@bluewatersys.com PO Box 13 889, Christchurch 8013
http://www.bluewatersys.com New Zealand
Phone: +64 3 3779127 Freecall: Australia 1800 148 751
Fax: +64 3 3779135 USA 1800 261 2934


\
 
 \ /
  Last update: 2011-01-20 05:21    [W:0.222 / U:6.300 seconds]
©2003-2018 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site