Change enums to u32 for stored fields
[yaffs2.git] / yaffs_guts.c
index 9f6b409..4e679bf 100644 (file)
@@ -631,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;
@@ -980,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 */
@@ -1377,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;
@@ -1442,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.
@@ -1462,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;
 }
 
@@ -1863,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;
@@ -3189,78 +3245,6 @@ static void yaffs_check_obj_details_loaded(struct yaffs_obj *in)
        yaffs_release_temp_buffer(dev, buf);
 }
 
-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;
-       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);
-       }
-}
-
 /* UpdateObjectHeader updates the header on NAND for an object.
  * If name is not NULL, then that new name is used.
  */
@@ -3765,7 +3749,7 @@ int yaffs_resize_file(struct yaffs_obj *in, loff_t new_size)
        struct yaffs_dev *dev = in->my_dev;
        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);
@@ -3798,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;
@@ -3950,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;
@@ -4029,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);
@@ -4593,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,
@@ -4610,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;
@@ -4653,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 =
@@ -4675,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;
 
@@ -4931,8 +5019,15 @@ 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;
 
@@ -5000,40 +5095,6 @@ int yaffs_get_n_free_chunks(struct yaffs_dev *dev)
 }
 
 
-int yaffs_format_dev(struct yaffs_dev *dev)
-{
-       int i;
-       enum yaffs_block_state state;
-       u32 dummy;
-
-       if(dev->is_mounted)
-               return YAFFS_FAIL;
-
-       /*
-       * The runtime variables might not have been set up,
-       * so set up what we need.
-       */
-       dev->internal_start_block = dev->param.start_block;
-       dev->internal_end_block = dev->param.end_block;
-       dev->block_offset = 0;
-       dev->chunk_offset = 0;
-
-       if (dev->param.start_block == 0) {
-               dev->internal_start_block = dev->param.start_block + 1;
-               dev->internal_end_block = dev->param.end_block + 1;
-               dev->block_offset = 1;
-               dev->chunk_offset = dev->param.chunks_per_block;
-       }
-
-       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;
-}
-
 
 /*
  * Marshalling functions to get loff_t file sizes into and out of
@@ -5057,3 +5118,23 @@ loff_t yaffs_oh_to_size(struct yaffs_obj_hdr *oh)
 
        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]++;
+       }
+}