Change enums to u32 for stored fields
[yaffs2.git] / yaffs_guts.c
index 403ce11..4e679bf 100644 (file)
@@ -15,9 +15,9 @@
 #include "yaffs_trace.h"
 
 #include "yaffs_guts.h"
-#include "yaffs_tagsvalidity.h"
 #include "yaffs_getblockinfo.h"
 #include "yaffs_tagscompat.h"
+#include "yaffs_tagsmarshall.h"
 #include "yaffs_nand.h"
 #include "yaffs_yaffs1.h"
 #include "yaffs_yaffs2.h"
@@ -28,6 +28,7 @@
 #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
 static int yaffs_wr_data_obj(struct yaffs_obj *in, int inode_chunk,
                             const u8 *buffer, int n_bytes, int use_reserve);
 
-
+static void yaffs_fix_null_name(struct yaffs_obj *obj, YCHAR *name,
+                               int buffer_size);
 
 /* 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;
@@ -128,44 +130,30 @@ static int yaffs_init_tmp_buffers(struct yaffs_dev *dev)
        memset(dev->temp_buffer, 0, sizeof(dev->temp_buffer));
 
        for (i = 0; buf && i < YAFFS_N_TEMP_BUFFERS; i++) {
-               dev->temp_buffer[i].line = 0;   /* not in use */
-               dev->temp_buffer[i].buffer = buf =
-                   kmalloc(dev->param.total_bytes_per_chunk, GFP_NOFS);
+               dev->temp_buffer[i].in_use = 0;
+               buf = kmalloc(dev->param.total_bytes_per_chunk, GFP_NOFS);
+               dev->temp_buffer[i].buffer = buf;
        }
 
        return buf ? YAFFS_OK : YAFFS_FAIL;
 }
 
-u8 *yaffs_get_temp_buffer(struct yaffs_dev * dev, int line_no)
+u8 *yaffs_get_temp_buffer(struct yaffs_dev * dev)
 {
        int i;
-       int j;
 
        dev->temp_in_use++;
        if (dev->temp_in_use > dev->max_temp)
                dev->max_temp = dev->temp_in_use;
 
        for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) {
-               if (dev->temp_buffer[i].line == 0) {
-                       dev->temp_buffer[i].line = line_no;
-                       if ((i + 1) > dev->max_temp) {
-                               dev->max_temp = i + 1;
-                               for (j = 0; j <= i; j++)
-                                       dev->temp_buffer[j].max_line =
-                                           dev->temp_buffer[j].line;
-                       }
-
+               if (dev->temp_buffer[i].in_use == 0) {
+                       dev->temp_buffer[i].in_use = 1;
                        return dev->temp_buffer[i].buffer;
                }
        }
 
-       yaffs_trace(YAFFS_TRACE_BUFFERS,
-               "Out of temp buffers at line %d, other held by lines:",
-               line_no);
-       for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++)
-               yaffs_trace(YAFFS_TRACE_BUFFERS,
-                       " %d", dev->temp_buffer[i].line);
-
+       yaffs_trace(YAFFS_TRACE_BUFFERS, "Out of temp buffers");
        /*
         * If we got here then we have to allocate an unmanaged one
         * This is not good.
@@ -176,7 +164,7 @@ u8 *yaffs_get_temp_buffer(struct yaffs_dev * dev, int line_no)
 
 }
 
-void yaffs_release_temp_buffer(struct yaffs_dev *dev, u8 *buffer, int line_no)
+void yaffs_release_temp_buffer(struct yaffs_dev *dev, u8 *buffer)
 {
        int i;
 
@@ -184,7 +172,7 @@ void yaffs_release_temp_buffer(struct yaffs_dev *dev, u8 *buffer, int line_no)
 
        for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) {
                if (dev->temp_buffer[i].buffer == buffer) {
-                       dev->temp_buffer[i].line = 0;
+                       dev->temp_buffer[i].in_use = 0;
                        return;
                }
        }
@@ -192,8 +180,7 @@ void yaffs_release_temp_buffer(struct yaffs_dev *dev, u8 *buffer, int line_no)
        if (buffer) {
                /* assume it is an unmanaged one. */
                yaffs_trace(YAFFS_TRACE_BUFFERS,
-                 "Releasing unmanaged temp buffer in line %d",
-                  line_no);
+                       "Releasing unmanaged temp buffer");
                kfree(buffer);
                dev->unmanaged_buffer_deallocs++;
        }
@@ -201,31 +188,6 @@ void yaffs_release_temp_buffer(struct yaffs_dev *dev, u8 *buffer, int line_no)
 }
 
 /*
- * 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
  *
  */
@@ -234,18 +196,18 @@ static void yaffs_handle_chunk_wr_ok(struct yaffs_dev *dev, int nand_chunk,
                                     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,
@@ -296,7 +258,8 @@ static void yaffs_handle_chunk_wr_error(struct yaffs_dev *dev, int nand_chunk,
 
 static inline int yaffs_hash_fn(int n)
 {
-       n = abs(n);
+       if (n < 0)
+               n = -n;
        return n % YAFFS_NOBJECT_BUCKETS;
 }
 
@@ -333,7 +296,7 @@ int yaffs_check_ff(u8 *buffer, int n_bytes)
 static int yaffs_check_chunk_erased(struct yaffs_dev *dev, int nand_chunk)
 {
        int retval = YAFFS_OK;
-       u8 *data = yaffs_get_temp_buffer(dev, __LINE__);
+       u8 *data = yaffs_get_temp_buffer(dev);
        struct yaffs_ext_tags tags;
        int result;
 
@@ -349,7 +312,7 @@ static int yaffs_check_chunk_erased(struct yaffs_dev *dev, int nand_chunk)
                retval = YAFFS_FAIL;
        }
 
-       yaffs_release_temp_buffer(dev, data, __LINE__);
+       yaffs_release_temp_buffer(dev, data);
 
        return retval;
 
@@ -362,7 +325,7 @@ static int yaffs_verify_chunk_written(struct yaffs_dev *dev,
 {
        int retval = YAFFS_OK;
        struct yaffs_ext_tags temp_tags;
-       u8 *buffer = yaffs_get_temp_buffer(dev, __LINE__);
+       u8 *buffer = yaffs_get_temp_buffer(dev);
        int result;
 
        result = yaffs_rd_chunk_tags_nand(dev, nand_chunk, buffer, &temp_tags);
@@ -372,7 +335,7 @@ static int yaffs_verify_chunk_written(struct yaffs_dev *dev,
            temp_tags.n_bytes != tags->n_bytes)
                retval = YAFFS_FAIL;
 
-       yaffs_release_temp_buffer(dev, buffer, __LINE__);
+       yaffs_release_temp_buffer(dev, buffer);
 
        return retval;
 }
@@ -614,7 +577,7 @@ static int yaffs_write_new_chunk(struct yaffs_dev *dev,
                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;
@@ -642,20 +605,20 @@ static void yaffs_retire_block(struct yaffs_dev *dev, int flash_block)
                        int chunk_id =
                            flash_block * dev->param.chunks_per_block;
 
-                       u8 *buffer = yaffs_get_temp_buffer(dev, __LINE__);
+                       u8 *buffer = yaffs_get_temp_buffer(dev);
 
                        memset(buffer, 0xff, dev->data_bytes_per_chunk);
-                       yaffs_init_tags(&tags);
+                       memset(&tags, 0, sizeof(tags));
                        tags.seq_number = YAFFS_SEQUENCE_BAD_BLOCK;
-                       if (dev->param.write_chunk_tags_fn(dev, chunk_id -
-                                                          dev->chunk_offset,
-                                                          buffer,
-                                                          &tags) != YAFFS_OK)
+                       if (dev->tagger.write_chunk_tags_fn(dev, chunk_id -
+                                                       dev->chunk_offset,
+                                                       buffer,
+                                                       &tags) != YAFFS_OK)
                                yaffs_trace(YAFFS_TRACE_ALWAYS,
                                        "yaffs: Failed to write bad block marker to block %d",
                                        flash_block);
 
-                       yaffs_release_temp_buffer(dev, buffer, __LINE__);
+                       yaffs_release_temp_buffer(dev, buffer);
                }
        }
 
@@ -668,6 +631,78 @@ static void yaffs_retire_block(struct yaffs_dev *dev, int flash_block)
 
 /*---------------- Name handling functions ------------*/
 
+static void yaffs_load_name_from_oh(struct yaffs_dev *dev, YCHAR *name,
+                                   const YCHAR *oh_name, int buff_size)
+{
+#ifdef CONFIG_YAFFS_AUTO_UNICODE
+       if (dev->param.auto_unicode) {
+               if (*oh_name) {
+                       /* It is an ASCII name, do an ASCII to
+                        * unicode conversion */
+                       const char *ascii_oh_name = (const char *)oh_name;
+                       int n = buff_size - 1;
+                       while (n > 0 && *ascii_oh_name) {
+                               *name = *ascii_oh_name;
+                               name++;
+                               ascii_oh_name++;
+                               n--;
+                       }
+               } else {
+                       strncpy(name, oh_name + 1, buff_size - 1);
+               }
+       } else {
+#else
+       (void) dev;
+       {
+#endif
+               strncpy(name, oh_name, buff_size - 1);
+       }
+}
+
+static void yaffs_load_oh_from_name(struct yaffs_dev *dev, YCHAR *oh_name,
+                                   const YCHAR *name)
+{
+#ifdef CONFIG_YAFFS_AUTO_UNICODE
+
+       int is_ascii;
+       const YCHAR *w;
+
+       if (dev->param.auto_unicode) {
+
+               is_ascii = 1;
+               w = name;
+
+               /* Figure out if the name will fit in ascii character set */
+               while (is_ascii && *w) {
+                       if ((*w) & 0xff00)
+                               is_ascii = 0;
+                       w++;
+               }
+
+               if (is_ascii) {
+                       /* It is an ASCII name, so convert unicode to ascii */
+                       char *ascii_oh_name = (char *)oh_name;
+                       int n = YAFFS_MAX_NAME_LENGTH - 1;
+                       while (n > 0 && *name) {
+                               *ascii_oh_name = *name;
+                               name++;
+                               ascii_oh_name++;
+                               n--;
+                       }
+               } else {
+                       /* Unicode name, so save starting at the second YCHAR */
+                       *oh_name = 0;
+                       strncpy(oh_name + 1, name, YAFFS_MAX_NAME_LENGTH - 2);
+               }
+       } else {
+#else
+       dev = dev;
+       {
+#endif
+               strncpy(oh_name, name, YAFFS_MAX_NAME_LENGTH - 1);
+       }
+}
+
 static u16 yaffs_calc_name_sum(const YCHAR *name)
 {
        u16 sum = 0;
@@ -686,17 +721,21 @@ static u16 yaffs_calc_name_sum(const YCHAR *name)
        return sum;
 }
 
+
 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 &&
+
+       if (name && !name[0]) {
+               yaffs_fix_null_name(obj, obj->short_name,
+                               YAFFS_SHORT_NAME_LENGTH);
+               name = obj->short_name;
+       } else if (name &&
                strnlen(name, YAFFS_SHORT_NAME_LENGTH + 1) <=
-               YAFFS_SHORT_NAME_LENGTH)
+               YAFFS_SHORT_NAME_LENGTH)  {
                strcpy(obj->short_name, name);
-       else
-               obj->short_name[0] = _Y('\0');
-#endif
+       }
+
        obj->sum = yaffs_calc_name_sum(name);
 }
 
@@ -714,6 +753,14 @@ void yaffs_set_obj_name_from_oh(struct yaffs_obj *obj,
 #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
@@ -750,7 +797,7 @@ static void yaffs_deinit_tnodes_and_objs(struct yaffs_dev *dev)
        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;
@@ -827,7 +874,7 @@ struct yaffs_tnode *yaffs_find_tnode_0(struct yaffs_dev *dev,
        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)
@@ -1005,7 +1052,7 @@ static int yaffs_find_chunk_in_group(struct yaffs_dev *dev, int the_chunk,
        return -1;
 }
 
-static int yaffs_find_chunk_in_file(struct yaffs_obj *in, int inode_chunk,
+int yaffs_find_chunk_in_file(struct yaffs_obj *in, int inode_chunk,
                                    struct yaffs_ext_tags *tags)
 {
        /*Get the Tnode, then get the level 0 offset chunk offset */
@@ -1402,56 +1449,49 @@ static int yaffs_obj_cache_dirty(struct yaffs_obj *obj)
        return 0;
 }
 
-static void yaffs_flush_file_cache(struct yaffs_obj *obj)
+static void yaffs_flush_single_cache(struct yaffs_cache *cache, int discard)
+{
+
+       if (!cache || cache->locked)
+               return;
+
+       /* Write it out and free it up  if need be.*/
+       if (cache->dirty) {
+               yaffs_wr_data_obj(cache->object,
+                                 cache->chunk_id,
+                                 cache->data,
+                                 cache->n_bytes,
+                                 1);
+
+               cache->dirty = 0;
+       }
+
+       if (discard)
+               cache->object = NULL;
+}
+
+static void yaffs_flush_file_cache(struct yaffs_obj *obj, int discard)
 {
        struct yaffs_dev *dev = obj->my_dev;
-       int lowest = -99;       /* Stop compiler whining. */
        int i;
        struct yaffs_cache *cache;
-       int chunk_written = 0;
        int n_caches = obj->my_dev->param.n_caches;
 
        if (n_caches < 1)
                return;
-       do {
-               cache = NULL;
-
-               /* Find the lowest dirty chunk for this object */
-               for (i = 0; i < n_caches; i++) {
-                       if (dev->cache[i].object == obj &&
-                           dev->cache[i].dirty) {
-                               if (!cache ||
-                                   dev->cache[i].chunk_id < lowest) {
-                                       cache = &dev->cache[i];
-                                       lowest = cache->chunk_id;
-                               }
-                       }
-               }
 
-               if (cache && !cache->locked) {
-                       /* Write it out and free it up */
-                       chunk_written =
-                           yaffs_wr_data_obj(cache->object,
-                                             cache->chunk_id,
-                                             cache->data,
-                                             cache->n_bytes, 1);
-                       cache->dirty = 0;
-                       cache->object = NULL;
-               }
-       } while (cache && chunk_written > 0);
 
-       if (cache)
-               /* Hoosterman, disk full while writing cache out. */
-               yaffs_trace(YAFFS_TRACE_ERROR,
-                       "yaffs tragedy: no space during cache write");
+       /* Find the chunks for this object and flush them. */
+       for (i = 0; i < n_caches; i++) {
+               cache = &dev->cache[i];
+               if (cache->object == obj)
+                       yaffs_flush_single_cache(cache, discard);
+       }
+
 }
 
-/*yaffs_flush_whole_cache(dev)
- *
- *
- */
 
-void yaffs_flush_whole_cache(struct yaffs_dev *dev)
+void yaffs_flush_whole_cache(struct yaffs_dev *dev, int discard)
 {
        struct yaffs_obj *obj;
        int n_caches = dev->param.n_caches;
@@ -1467,12 +1507,12 @@ void yaffs_flush_whole_cache(struct yaffs_dev *dev)
                                obj = dev->cache[i].object;
                }
                if (obj)
-                       yaffs_flush_file_cache(obj);
+                       yaffs_flush_file_cache(obj, discard);
        } while (obj);
 
 }
 
-/* Grab us a cache chunk for use.
+/* Grab us an unused cache chunk for use.
  * First look for an empty one.
  * Then look for the least recently used non-dirty one.
  * Then look for the least recently used dirty one...., flush and look again.
@@ -1487,56 +1527,50 @@ static struct yaffs_cache *yaffs_grab_chunk_worker(struct yaffs_dev *dev)
                                return &dev->cache[i];
                }
        }
+
        return NULL;
 }
 
 static struct yaffs_cache *yaffs_grab_chunk_cache(struct yaffs_dev *dev)
 {
        struct yaffs_cache *cache;
-       struct yaffs_obj *the_obj;
        int usage;
        int i;
-       int pushout;
 
        if (dev->param.n_caches < 1)
                return NULL;
 
-       /* Try find a non-dirty one... */
+       /* First look for an unused cache */
 
        cache = yaffs_grab_chunk_worker(dev);
 
-       if (!cache) {
-               /* They were all dirty, find the LRU object and flush
-                * its cache, then  find again.
-                * NB what's here is not very accurate,
-                * we actually flush the object with the LRU chunk.
-                */
+       if (cache)
+               return cache;
 
-               /* With locking we can't assume we can use entry zero,
-                * Set the_obj to a valid pointer for Coverity. */
-               the_obj = dev->cache[0].object;
-               usage = -1;
-               cache = NULL;
-               pushout = -1;
+       /*
+        * Thery were all in use.
+        * Find the LRU cache and flush it if it is dirty.
+        */
 
-               for (i = 0; i < dev->param.n_caches; i++) {
-                       if (dev->cache[i].object &&
-                           !dev->cache[i].locked &&
-                           (dev->cache[i].last_use < usage ||
-                           !cache)) {
+       usage = -1;
+       cache = NULL;
+
+       for (i = 0; i < dev->param.n_caches; i++) {
+               if (dev->cache[i].object &&
+                   !dev->cache[i].locked &&
+                   (dev->cache[i].last_use < usage || !cache)) {
                                usage = dev->cache[i].last_use;
-                               the_obj = dev->cache[i].object;
                                cache = &dev->cache[i];
-                               pushout = i;
-                       }
-               }
-
-               if (!cache || cache->dirty) {
-                       /* Flush and try again */
-                       yaffs_flush_file_cache(the_obj);
-                       cache = yaffs_grab_chunk_worker(dev);
                }
        }
+
+#if 1
+       yaffs_flush_single_cache(cache, 1);
+#else
+       yaffs_flush_file_cache(cache->object, 1);
+       cache = yaffs_grab_chunk_worker(dev);
+#endif
+
        return cache;
 }
 
@@ -1888,21 +1922,18 @@ static int yaffs_new_obj_id(struct yaffs_dev *dev)
        struct list_head *i;
        u32 n = (u32) bucket;
 
-       /* Now find an object value that has not already been taken
-        * by scanning the list.
+       /*
+        * Now find an object value that has not already been taken
+        * by scanning the list, incrementing each time by number of buckets.
         */
-
        while (!found) {
                found = 1;
                n += YAFFS_NOBJECT_BUCKETS;
-               if (1 || dev->obj_bucket[bucket].count > 0) {
-                       list_for_each(i, &dev->obj_bucket[bucket].list) {
-                               /* If there is already one in the list */
-                               if (i && list_entry(i, struct yaffs_obj,
-                                                   hash_link)->obj_id == n) {
-                                       found = 0;
-                               }
-                       }
+               list_for_each(i, &dev->obj_bucket[bucket].list) {
+                       /* Check if this value is already taken. */
+                       if (i && list_entry(i, struct yaffs_obj,
+                                           hash_link)->obj_id == n)
+                               found = 0;
                }
        }
        return n;
@@ -1937,7 +1968,7 @@ struct yaffs_obj *yaffs_find_by_number(struct yaffs_dev *dev, u32 number)
        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;
@@ -1971,7 +2002,8 @@ struct yaffs_obj *yaffs_new_obj(struct yaffs_dev *dev, int number,
        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;
@@ -2399,6 +2431,8 @@ void yaffs_block_became_dirty(struct yaffs_dev *dev, int block_no)
        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);
@@ -2415,7 +2449,7 @@ static inline int yaffs_gc_process_chunk(struct yaffs_dev *dev,
        int matching_chunk;
        int ret_val = YAFFS_OK;
 
-       yaffs_init_tags(&tags);
+       memset(&tags, 0, sizeof(tags));
        yaffs_rd_chunk_tags_nand(dev, old_chunk,
                                 buffer, &tags);
        object = yaffs_find_by_number(dev, tags.obj_id);
@@ -2512,9 +2546,10 @@ static inline int yaffs_gc_process_chunk(struct yaffs_dev *dev,
 
                        /* 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);
@@ -2574,6 +2609,8 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block, int whole_block)
 
        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",
@@ -2581,7 +2618,7 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block, int whole_block)
                yaffs_block_became_dirty(dev, block);
        } else {
 
-               u8 *buffer = yaffs_get_temp_buffer(dev, __LINE__);
+               u8 *buffer = yaffs_get_temp_buffer(dev);
 
                yaffs_verify_blk(dev, bi, block);
 
@@ -2601,7 +2638,7 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block, int whole_block)
                                                        old_chunk, buffer);
                        }
                }
-               yaffs_release_temp_buffer(dev, buffer, __LINE__);
+               yaffs_release_temp_buffer(dev, buffer);
        }
 
        yaffs_verify_collected_blk(dev, bi, block);
@@ -2824,7 +2861,8 @@ static int yaffs_check_gc(struct yaffs_dev *dev, int background)
        int erased_chunks;
        int checkpt_block_adjust;
 
-       if (dev->param.gc_control && (dev->param.gc_control(dev) & 1) == 0)
+       if (dev->param.gc_control_fn &&
+               (dev->param.gc_control_fn(dev) & 1) == 0)
                return YAFFS_OK;
 
        if (dev->gc_disable)
@@ -2971,7 +3009,7 @@ void yaffs_chunk_del(struct yaffs_dev *dev, int chunk_id, int mark_flash,
        if (!dev->param.is_yaffs2 && mark_flash &&
            bi->block_state != YAFFS_BLOCK_STATE_COLLECTING) {
 
-               yaffs_init_tags(&tags);
+               memset(&tags, 0, sizeof(tags));
                tags.is_deleted = 1;
                yaffs_wr_chunk_tags_nand(dev, chunk_id, NULL, &tags);
                yaffs_handle_chunk_update(dev, chunk_id, &tags);
@@ -3025,7 +3063,7 @@ static int yaffs_wr_data_obj(struct yaffs_obj *in, int inode_chunk,
                return 0;
 
        /* Set up new tags */
-       yaffs_init_tags(&new_tags);
+       memset(&new_tags, 0, sizeof(new_tags));
 
        new_tags.chunk_id = inode_chunk;
        new_tags.obj_id = in->obj_id;
@@ -3127,7 +3165,7 @@ static int yaffs_do_xattrib_fetch(struct yaffs_obj *obj, const YCHAR *name,
                        return 0;
        }
 
-       buffer = (char *)yaffs_get_temp_buffer(dev, __LINE__);
+       buffer = (char *)yaffs_get_temp_buffer(dev);
        if (!buffer)
                return -ENOMEM;
 
@@ -3149,7 +3187,7 @@ static int yaffs_do_xattrib_fetch(struct yaffs_obj *obj, const YCHAR *name,
                else
                        retval = nval_list(x_buffer, x_size, value, size);
        }
-       yaffs_release_temp_buffer(dev, (u8 *) buffer, __LINE__);
+       yaffs_release_temp_buffer(dev, (u8 *) buffer);
        return retval;
 }
 
@@ -3189,7 +3227,7 @@ static void yaffs_check_obj_details_loaded(struct yaffs_obj *in)
 
        dev = in->my_dev;
        in->lazy_loaded = 0;
-       buf = yaffs_get_temp_buffer(dev, __LINE__);
+       buf = yaffs_get_temp_buffer(dev);
 
        result = yaffs_rd_chunk_tags_nand(dev, in->hdr_chunk, buf, &tags);
        oh = (struct yaffs_obj_hdr *)buf;
@@ -3204,77 +3242,7 @@ static void yaffs_check_obj_details_loaded(struct yaffs_obj *in)
                if (!in->variant.symlink_variant.alias)
                        alloc_failed = 1;       /* Not returned */
        }
-       yaffs_release_temp_buffer(dev, buf, __LINE__);
-}
-
-static void yaffs_load_name_from_oh(struct yaffs_dev *dev, YCHAR *name,
-                                   const YCHAR *oh_name, int buff_size)
-{
-#ifdef CONFIG_YAFFS_AUTO_UNICODE
-       if (dev->param.auto_unicode) {
-               if (*oh_name) {
-                       /* It is an ASCII name, do an ASCII to
-                        * unicode conversion */
-                       const char *ascii_oh_name = (const char *)oh_name;
-                       int n = buff_size - 1;
-                       while (n > 0 && *ascii_oh_name) {
-                               *name = *ascii_oh_name;
-                               name++;
-                               ascii_oh_name++;
-                               n--;
-                       }
-               } else {
-                       strncpy(name, oh_name + 1, buff_size - 1);
-               }
-       } else {
-#else
-       {
-#endif
-               strncpy(name, oh_name, buff_size - 1);
-       }
-}
-
-static void yaffs_load_oh_from_name(struct yaffs_dev *dev, YCHAR *oh_name,
-                                   const YCHAR *name)
-{
-#ifdef CONFIG_YAFFS_AUTO_UNICODE
-
-       int is_ascii;
-       YCHAR *w;
-
-       if (dev->param.auto_unicode) {
-
-               is_ascii = 1;
-               w = name;
-
-               /* Figure out if the name will fit in ascii character set */
-               while (is_ascii && *w) {
-                       if ((*w) & 0xff00)
-                               is_ascii = 0;
-                       w++;
-               }
-
-               if (is_ascii) {
-                       /* It is an ASCII name, so convert unicode to ascii */
-                       char *ascii_oh_name = (char *)oh_name;
-                       int n = YAFFS_MAX_NAME_LENGTH - 1;
-                       while (n > 0 && *name) {
-                               *ascii_oh_name = *name;
-                               name++;
-                               ascii_oh_name++;
-                               n--;
-                       }
-               } else {
-                       /* Unicode name, so save starting at the second YCHAR */
-                       *oh_name = 0;
-                       strncpy(oh_name + 1, name, YAFFS_MAX_NAME_LENGTH - 2);
-               }
-       } else {
-#else
-       {
-#endif
-               strncpy(oh_name, name, YAFFS_MAX_NAME_LENGTH - 1);
-       }
+       yaffs_release_temp_buffer(dev, buf);
 }
 
 /* UpdateObjectHeader updates the header on NAND for an object.
@@ -3296,6 +3264,7 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name, int force,
        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"));
 
@@ -3305,7 +3274,7 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name, int force,
        yaffs_check_gc(dev, 0);
        yaffs_check_obj_details_loaded(in);
 
-       buffer = yaffs_get_temp_buffer(in->my_dev, __LINE__);
+       buffer = yaffs_get_temp_buffer(in->my_dev);
        oh = (struct yaffs_obj_hdr *)buffer;
 
        prev_chunk_id = in->hdr_chunk;
@@ -3348,10 +3317,10 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name, int force,
                /* 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;
@@ -3376,7 +3345,7 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name, int force,
                yaffs_apply_xattrib_mod(in, (char *)buffer, xmod);
 
        /* Tags */
-       yaffs_init_tags(&new_tags);
+       memset(&new_tags, 0, sizeof(new_tags));
        in->serial++;
        new_tags.chunk_id = 0;
        new_tags.obj_id = in->obj_id;
@@ -3385,7 +3354,7 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name, int force,
        /* 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;
@@ -3398,7 +3367,7 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name, int force,
                                  (prev_chunk_id > 0) ? 1 : 0);
 
        if (buffer)
-               yaffs_release_temp_buffer(dev, buffer, __LINE__);
+               yaffs_release_temp_buffer(dev, buffer);
 
        if (new_chunk_id < 0)
                return new_chunk_id;
@@ -3494,13 +3463,12 @@ int yaffs_file_rd(struct yaffs_obj *in, u8 * buffer, loff_t offset, int n_bytes)
                                /* Read into the local buffer then copy.. */
 
                                u8 *local_buffer =
-                                   yaffs_get_temp_buffer(dev, __LINE__);
+                                   yaffs_get_temp_buffer(dev);
                                yaffs_rd_data_obj(in, chunk, local_buffer);
 
                                memcpy(buffer, &local_buffer[start], n_copy);
 
-                               yaffs_release_temp_buffer(dev, local_buffer,
-                                                         __LINE__);
+                               yaffs_release_temp_buffer(dev, local_buffer);
                        }
                } else {
                        /* A full chunk. Read directly into the buffer. */
@@ -3515,7 +3483,7 @@ int yaffs_file_rd(struct yaffs_obj *in, u8 * buffer, loff_t offset, int n_bytes)
 }
 
 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;
@@ -3524,10 +3492,10 @@ int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset,
        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;
@@ -3535,11 +3503,12 @@ int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset,
        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 */
 
@@ -3556,7 +3525,8 @@ int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t 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 */
@@ -3582,9 +3552,11 @@ int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset,
                }
 
                if (n_copy != dev->data_bytes_per_chunk ||
+                   !dev->param.cache_bypass_aligned ||
                    dev->param.inband_tags) {
                        /* An incomplete start or end chunk (or maybe both
                         * start and end chunk), or we're using inband tags,
+                        * or we're forcing writes through the cache,
                         * so we want to use the cache buffers.
                         */
                        if (dev->param.n_caches > 0) {
@@ -3624,7 +3596,7 @@ int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset,
                                        cache->locked = 0;
                                        cache->n_bytes = n_writeback;
 
-                                       if (write_trhrough) {
+                                       if (write_through) {
                                                chunk_written =
                                                    yaffs_wr_data_obj
                                                    (cache->object,
@@ -3642,8 +3614,7 @@ int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset,
                                 * local buffer then copy over and write back.
                                 */
 
-                               u8 *local_buffer =
-                                   yaffs_get_temp_buffer(dev, __LINE__);
+                               u8 *local_buffer = yaffs_get_temp_buffer(dev);
 
                                yaffs_rd_data_obj(in, chunk, local_buffer);
                                memcpy(&local_buffer[start], buffer, n_copy);
@@ -3653,8 +3624,7 @@ int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset,
                                                      local_buffer,
                                                      n_writeback, 0);
 
-                               yaffs_release_temp_buffer(dev, local_buffer,
-                                                         __LINE__);
+                               yaffs_release_temp_buffer(dev, local_buffer);
                        }
                } else {
                        /* A full chunk. Write directly from the buffer. */
@@ -3686,25 +3656,34 @@ int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset,
 }
 
 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.
@@ -3747,7 +3726,7 @@ void yaffs_resize_file_down(struct yaffs_obj *obj, loff_t new_size)
 
        if (new_partial != 0) {
                int last_chunk = 1 + new_full;
-               u8 *local_buffer = yaffs_get_temp_buffer(dev, __LINE__);
+               u8 *local_buffer = yaffs_get_temp_buffer(dev);
 
                /* Rewrite the last chunk with its new size and zero pad */
                yaffs_rd_data_obj(obj, last_chunk, local_buffer);
@@ -3757,7 +3736,7 @@ void yaffs_resize_file_down(struct yaffs_obj *obj, loff_t new_size)
                yaffs_wr_data_obj(obj, last_chunk, local_buffer,
                                  new_partial, 1);
 
-               yaffs_release_temp_buffer(dev, local_buffer, __LINE__);
+               yaffs_release_temp_buffer(dev, local_buffer);
        }
 
        obj->variant.file_variant.file_size = new_size;
@@ -3768,9 +3747,9 @@ void yaffs_resize_file_down(struct yaffs_obj *obj, loff_t new_size)
 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_flush_file_cache(in, 1);
        yaffs_invalidate_whole_cache(in);
 
        yaffs_check_gc(dev, 0);
@@ -3803,12 +3782,15 @@ int yaffs_resize_file(struct yaffs_obj *in, loff_t new_size)
        return YAFFS_OK;
 }
 
-int yaffs_flush_file(struct yaffs_obj *in, int update_time, int data_sync)
+int yaffs_flush_file(struct yaffs_obj *in,
+                    int update_time,
+                    int data_sync,
+                    int discard_cache)
 {
        if (!in->dirty)
                return YAFFS_OK;
 
-       yaffs_flush_file_cache(in);
+       yaffs_flush_file_cache(in, discard_cache);
 
        if (data_sync)
                return YAFFS_OK;
@@ -3854,7 +3836,7 @@ static int yaffs_unlink_file_if_needed(struct yaffs_obj *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 */
@@ -3955,6 +3937,70 @@ int yaffs_del_obj(struct yaffs_obj *obj)
        return ret_val;
 }
 
+
+static void yaffs_empty_dir_to_dir(struct yaffs_obj *from_dir,
+                                  struct yaffs_obj *to_dir)
+{
+       struct yaffs_obj *obj;
+       struct list_head *lh;
+       struct list_head *n;
+
+       list_for_each_safe(lh, n, &from_dir->variant.dir_variant.children) {
+               obj = list_entry(lh, struct yaffs_obj, siblings);
+               yaffs_add_obj_to_dir(to_dir, obj);
+       }
+}
+
+struct yaffs_obj *yaffs_retype_obj(struct yaffs_obj *obj,
+                                  enum yaffs_obj_type type)
+{
+       /* Tear down the old variant */
+       switch (obj->variant_type) {
+       case YAFFS_OBJECT_TYPE_FILE:
+               /* Nuke file data */
+               yaffs_resize_file(obj, 0);
+               yaffs_free_tnode(obj->my_dev, obj->variant.file_variant.top);
+               obj->variant.file_variant.top = NULL;
+               break;
+       case YAFFS_OBJECT_TYPE_DIRECTORY:
+               /* Put the children in lost and found. */
+               yaffs_empty_dir_to_dir(obj, obj->my_dev->lost_n_found);
+               if (!list_empty(&obj->variant.dir_variant.dirty))
+                       list_del_init(&obj->variant.dir_variant.dirty);
+               break;
+       case YAFFS_OBJECT_TYPE_SYMLINK:
+               /* Nuke symplink data */
+               kfree(obj->variant.symlink_variant.alias);
+               obj->variant.symlink_variant.alias = NULL;
+               break;
+       case YAFFS_OBJECT_TYPE_HARDLINK:
+               list_del_init(&obj->hard_links);
+               break;
+       default:
+               break;
+       }
+
+       memset(&obj->variant, 0, sizeof(obj->variant));
+
+       /*Set up new variant if the memset is not enough. */
+       switch (type) {
+       case YAFFS_OBJECT_TYPE_DIRECTORY:
+               INIT_LIST_HEAD(&obj->variant.dir_variant.children);
+               INIT_LIST_HEAD(&obj->variant.dir_variant.dirty);
+               break;
+       case YAFFS_OBJECT_TYPE_FILE:
+       case YAFFS_OBJECT_TYPE_SYMLINK:
+       case YAFFS_OBJECT_TYPE_HARDLINK:
+       default:
+               break;
+       }
+
+       obj->variant_type = type;
+
+       return obj;
+
+}
+
 static int yaffs_unlink_worker(struct yaffs_obj *obj)
 {
        int del_now = 0;
@@ -4034,7 +4080,7 @@ static int yaffs_unlink_worker(struct yaffs_obj *obj)
        }
 }
 
-static int yaffs_unlink_obj(struct yaffs_obj *obj)
+int yaffs_unlink_obj(struct yaffs_obj *obj)
 {
        if (obj && obj->unlink_allowed)
                return yaffs_unlink_worker(obj);
@@ -4368,7 +4414,7 @@ struct yaffs_obj *yaffs_find_by_name(struct yaffs_obj *directory,
                         */
                        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;
                }
        }
@@ -4433,15 +4479,13 @@ int yaffs_get_obj_name(struct yaffs_obj *obj, YCHAR *name, int buffer_size)
 {
        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, __LINE__);
+               u8 *buffer = yaffs_get_temp_buffer(obj->my_dev);
 
                struct yaffs_obj_hdr *oh = (struct yaffs_obj_hdr *)buffer;
 
@@ -4455,7 +4499,7 @@ int yaffs_get_obj_name(struct yaffs_obj *obj, YCHAR *name, int buffer_size)
                yaffs_load_name_from_oh(obj->my_dev, name, oh->name,
                                        buffer_size);
 
-               yaffs_release_temp_buffer(obj->my_dev, buffer, __LINE__);
+               yaffs_release_temp_buffer(obj->my_dev, buffer);
        }
 
        yaffs_fix_null_name(obj, name, buffer_size);
@@ -4463,7 +4507,7 @@ int yaffs_get_obj_name(struct yaffs_obj *obj, YCHAR *name, int buffer_size)
        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);
@@ -4547,33 +4591,33 @@ YCHAR *yaffs_get_symlink_alias(struct yaffs_obj *obj)
 
 /*--------------------------- Initialisation code -------------------------- */
 
-static int yaffs_check_dev_fns(const struct yaffs_dev *dev)
+static int yaffs_check_dev_fns(struct yaffs_dev *dev)
 {
+       struct yaffs_driver *drv = &dev->drv;
+       struct yaffs_tags_handler *tagger = &dev->tagger;
+
        /* Common functions, gotta have */
-       if (!dev->param.erase_fn || !dev->param.initialise_flash_fn)
+       if (!drv->drv_read_chunk_fn ||
+           !drv->drv_write_chunk_fn ||
+           !drv->drv_erase_fn)
                return 0;
 
-#ifdef CONFIG_YAFFS_YAFFS2
+       if (dev->param.is_yaffs2 &&
+            (!drv->drv_mark_bad_fn  || !drv->drv_check_bad_fn))
+               return 0;
 
-       /* 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.write_chunk_fn &&
-           !dev->param.read_chunk_fn &&
-           dev->param.bad_block_fn && dev->param.query_block_fn)
-               return 1;
-#endif
+       /* Install the default tags marshalling functions if needed. */
+       yaffs_tags_compat_install(dev);
+       yaffs_tags_marshall_install(dev);
 
-       /* Can use the "spare" style interface for yaffs1 */
-       if (!dev->param.is_yaffs2 &&
-           !dev->param.write_chunk_tags_fn &&
-           !dev->param.read_chunk_tags_fn &&
-           dev->param.write_chunk_fn &&
-           dev->param.read_chunk_fn &&
-           !dev->param.bad_block_fn && !dev->param.query_block_fn)
-               return 1;
+       /* Check we now have the marshalling functions required. */
+       if (!tagger->write_chunk_tags_fn ||
+           !tagger->read_chunk_tags_fn ||
+           !tagger->query_block_fn ||
+           !tagger->mark_bad_fn)
+               return 0;
 
-       return 0;               /* bad */
+       return 1;
 }
 
 static int yaffs_create_initial_dir(struct yaffs_dev *dev)
@@ -4600,15 +4644,16 @@ static int yaffs_create_initial_dir(struct yaffs_dev *dev)
        return YAFFS_FAIL;
 }
 
-int yaffs_guts_initialise(struct yaffs_dev *dev)
+/* Low level init.
+ * Typically only used by yaffs_guts_initialise, but also used by the
+ * Low level yaffs driver tests.
+ */
+
+int yaffs_guts_ll_init(struct yaffs_dev *dev)
 {
-       int init_failed = 0;
-       unsigned x;
-       int bits;
 
-       yaffs_trace(YAFFS_TRACE_TRACING, "yaffs: yaffs_guts_initialise()");
 
-       /* Check stuff that must be set */
+       yaffs_trace(YAFFS_TRACE_TRACING, "yaffs: yaffs_ll_init()");
 
        if (!dev) {
                yaffs_trace(YAFFS_TRACE_ALWAYS,
@@ -4617,10 +4662,8 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
                return YAFFS_FAIL;
        }
 
-       if (dev->is_mounted) {
-               yaffs_trace(YAFFS_TRACE_ALWAYS, "device already mounted");
-               return YAFFS_FAIL;
-       }
+       if (dev->ll_init)
+               return YAFFS_OK;
 
        dev->internal_start_block = dev->param.start_block;
        dev->internal_end_block = dev->param.end_block;
@@ -4660,11 +4703,6 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
                return YAFFS_FAIL;
        }
 
-       if (yaffs_init_nand(dev) != YAFFS_OK) {
-               yaffs_trace(YAFFS_TRACE_ALWAYS, "InitialiseNAND failed");
-               return YAFFS_FAIL;
-       }
-
        /* Sort out space for inband tags, if required */
        if (dev->param.inband_tags)
                dev->data_bytes_per_chunk =
@@ -4682,7 +4720,50 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
                return YAFFS_FAIL;
        }
 
-       /* Finished with most checks. Further checks happen later on too. */
+       if (yaffs_init_nand(dev) != YAFFS_OK) {
+               yaffs_trace(YAFFS_TRACE_ALWAYS, "InitialiseNAND failed");
+               return YAFFS_FAIL;
+       }
+
+       return YAFFS_OK;
+}
+
+
+int yaffs_guts_format_dev(struct yaffs_dev *dev)
+{
+       int i;
+       enum yaffs_block_state state;
+       u32 dummy;
+
+       if(yaffs_guts_ll_init(dev) != YAFFS_OK)
+               return YAFFS_FAIL;
+
+       if(dev->is_mounted)
+               return YAFFS_FAIL;
+
+       for (i = dev->internal_start_block; i <= dev->internal_end_block; i++) {
+               yaffs_query_init_block_state(dev, i, &state, &dummy);
+               if (state != YAFFS_BLOCK_STATE_DEAD)
+                       yaffs_erase_block(dev, i);
+       }
+
+       return YAFFS_OK;
+}
+
+
+int yaffs_guts_initialise(struct yaffs_dev *dev)
+{
+       int init_failed = 0;
+       unsigned x;
+       int bits;
+
+       if(yaffs_guts_ll_init(dev) != YAFFS_OK)
+               return YAFFS_FAIL;
+
+       if (dev->is_mounted) {
+               yaffs_trace(YAFFS_TRACE_ALWAYS, "device already mounted");
+               return YAFFS_FAIL;
+       }
 
        dev->is_mounted = 1;
 
@@ -4833,6 +4914,11 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
        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) {
@@ -4895,7 +4981,7 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
        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;
 
@@ -4918,6 +5004,8 @@ void yaffs_deinitialise(struct yaffs_dev *dev)
 
                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++) {
@@ -4931,13 +5019,19 @@ void yaffs_deinitialise(struct yaffs_dev *dev)
 
                kfree(dev->gc_cleanup_list);
 
-               for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++)
+               for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) {
                        kfree(dev->temp_buffer[i].buffer);
+                       dev->temp_buffer[i].buffer = NULL;
+               }
+
+               kfree(dev->checkpt_buffer);
+               dev->checkpt_buffer = NULL;
+               kfree(dev->checkpt_block_list);
+               dev->checkpt_block_list = NULL;
 
                dev->is_mounted = 0;
 
-               if (dev->param.deinitialise_flash_fn)
-                       dev->param.deinitialise_flash_fn(dev);
+               yaffs_deinit_nand(dev);
        }
 }
 
@@ -4999,3 +5093,48 @@ int yaffs_get_n_free_chunks(struct yaffs_dev *dev)
 
        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;
+}
+
+
+void yaffs_count_blocks_by_state(struct yaffs_dev *dev, int bs[10])
+{
+       int i;
+       struct yaffs_block_info *bi;
+       int s;
+
+       for(i = 0; i < 10; i++)
+               bs[i] = 0;
+
+       for(i = dev->internal_start_block; i <= dev->internal_end_block; i++) {
+               bi = yaffs_get_block_info(dev, i);
+               s = bi->block_state;
+               if(s > YAFFS_BLOCK_STATE_DEAD || s < YAFFS_BLOCK_STATE_UNKNOWN)
+                       bs[0]++;
+               else
+                       bs[s]++;
+       }
+}