X-Git-Url: http://www.aleph1.co.uk/gitweb/?p=yaffs2.git;a=blobdiff_plain;f=yaffs_guts.c;h=ce7ed7ebb870ff3a548781f5d817c782e6d2a69e;hp=06bb13c1cb3a69ac246f3cabbee4e4ec4e5f8220;hb=a233a8fc212a32a50cc5f572cd4946e91cc9ca93;hpb=976dbeae825b18e6759f3903073a6784248cc244

diff --git a/yaffs_guts.c b/yaffs_guts.c
index 06bb13c..ce7ed7e 100644
--- a/yaffs_guts.c
+++ b/yaffs_guts.c
@@ -33,6 +33,8 @@
 #include "yaffs_nameval.h"
 #include "yaffs_allocator.h"
 
+#include "yaffs_attribs.h"
+
 /* Note YAFFS_GC_GOOD_ENOUGH must be <= YAFFS_GC_PASSIVE_THRESHOLD */
 #define YAFFS_GC_GOOD_ENOUGH 2
 #define YAFFS_GC_PASSIVE_THRESHOLD 4
@@ -66,10 +68,9 @@ static struct yaffs_obj *yaffs_new_obj(struct yaffs_dev *dev, int number,
 					enum yaffs_obj_type type);
 
 
-static int yaffs_apply_xattrib_mod(struct yaffs_obj *obj, char *buffer, yaffs_xattr_mod *xmod);
+static int yaffs_apply_xattrib_mod(struct yaffs_obj *obj, char *buffer, struct yaffs_xattr_mod *xmod);
 
 static void yaffs_remove_obj_from_dir(struct yaffs_obj *obj);
-static int yaffs_check_structures(void);
 static int yaffs_generic_obj_del(struct yaffs_obj *in);
 
 static int yaffs_check_chunk_erased(struct yaffs_dev *dev,
@@ -81,7 +82,7 @@ static int yaffs_tags_match(const struct yaffs_ext_tags *tags, int obj_id,
 			int chunk_obj);
 
 static int yaffs_alloc_chunk(struct yaffs_dev *dev, int use_reserver,
-				yaffs_block_info_t **block_ptr);
+				struct yaffs_block_info **block_ptr);
 
 static void yaffs_check_obj_details_loaded(struct yaffs_obj *in);
 
@@ -395,7 +396,7 @@ static int yaffs_write_new_chunk(struct yaffs_dev *dev,
 	yaffs2_checkpt_invalidate(dev);
 
 	do {
-		yaffs_block_info_t *bi = 0;
+		struct yaffs_block_info *bi = 0;
 		int erased_ok = 0;
 
 		chunk = yaffs_alloc_chunk(dev, use_reserver, &bi);
@@ -493,7 +494,7 @@ static int yaffs_write_new_chunk(struct yaffs_dev *dev,
 
 static void yaffs_retire_block(struct yaffs_dev *dev, int flash_block)
 {
-	yaffs_block_info_t *bi = yaffs_get_block_info(dev, flash_block);
+	struct yaffs_block_info *bi = yaffs_get_block_info(dev, flash_block);
 
 	yaffs2_checkpt_invalidate(dev);
 	
@@ -553,7 +554,7 @@ static void yaffs_handle_chunk_update(struct yaffs_dev *dev, int nand_chunk,
 	tags=tags;
 }
 
-void yaffs_handle_chunk_error(struct yaffs_dev *dev, yaffs_block_info_t *bi)
+void yaffs_handle_chunk_error(struct yaffs_dev *dev, struct yaffs_block_info *bi)
 {
 	if (!bi->gc_prioritise) {
 		bi->gc_prioritise = 1;
@@ -572,7 +573,7 @@ static void yaffs_handle_chunk_wr_error(struct yaffs_dev *dev, int nand_chunk,
 		int erased_ok)
 {
 	int flash_block = nand_chunk / dev->param.chunks_per_block;
-	yaffs_block_info_t *bi = yaffs_get_block_info(dev, flash_block);
+	struct yaffs_block_info *bi = yaffs_get_block_info(dev, flash_block);
 
 	yaffs_handle_chunk_error(dev, bi);
 
@@ -641,9 +642,9 @@ void yaffs_set_obj_name_from_oh(struct yaffs_obj *obj, const struct yaffs_obj_hd
  */
 
 
-yaffs_tnode_t *yaffs_get_tnode(struct yaffs_dev *dev)
+struct yaffs_tnode *yaffs_get_tnode(struct yaffs_dev *dev)
 {
-	yaffs_tnode_t *tn = yaffs_alloc_raw_tnode(dev);
+	struct yaffs_tnode *tn = yaffs_alloc_raw_tnode(dev);
 	if (tn){
 		memset(tn, 0, dev->tnode_size);
 		dev->n_tnodes++;
@@ -655,7 +656,7 @@ yaffs_tnode_t *yaffs_get_tnode(struct yaffs_dev *dev)
 }
 
 /* FreeTnode frees up a tnode and puts it back on the free list */
-static void yaffs_free_tnode(struct yaffs_dev *dev, yaffs_tnode_t *tn)
+static void yaffs_free_tnode(struct yaffs_dev *dev, struct yaffs_tnode *tn)
 {
 	yaffs_free_raw_tnode(dev,tn);
 	dev->n_tnodes--;
@@ -670,7 +671,7 @@ static void yaffs_deinit_tnodes_and_objs(struct yaffs_dev *dev)
 }
 
 
-void yaffs_load_tnode_0(struct yaffs_dev *dev, yaffs_tnode_t *tn, unsigned pos,
+void yaffs_load_tnode_0(struct yaffs_dev *dev, struct yaffs_tnode *tn, unsigned pos,
 		unsigned val)
 {
 	u32 *map = (u32 *)tn;
@@ -700,7 +701,7 @@ void yaffs_load_tnode_0(struct yaffs_dev *dev, yaffs_tnode_t *tn, unsigned pos,
 	}
 }
 
-u32 yaffs_get_group_base(struct yaffs_dev *dev, yaffs_tnode_t *tn,
+u32 yaffs_get_group_base(struct yaffs_dev *dev, struct yaffs_tnode *tn,
 		unsigned pos)
 {
 	u32 *map = (u32 *)tn;
@@ -737,11 +738,11 @@ u32 yaffs_get_group_base(struct yaffs_dev *dev, yaffs_tnode_t *tn,
  */
 
 /* FindLevel0Tnode finds the level 0 tnode, if one exists. */
-yaffs_tnode_t *yaffs_find_tnode_0(struct yaffs_dev *dev,
-					yaffs_file_s *file_struct,
+struct yaffs_tnode *yaffs_find_tnode_0(struct yaffs_dev *dev,
+					struct yaffs_file_var *file_struct,
 					u32 chunk_id)
 {
-	yaffs_tnode_t *tn = file_struct->top;
+	struct yaffs_tnode *tn = file_struct->top;
 	u32 i;
 	int required_depth;
 	int level = file_struct->top_level;
@@ -791,15 +792,15 @@ yaffs_tnode_t *yaffs_find_tnode_0(struct yaffs_dev *dev,
  *  be plugged into the ttree.
  */
 
-yaffs_tnode_t *yaffs_add_find_tnode_0(struct yaffs_dev *dev,
-					yaffs_file_s *file_struct,
+struct yaffs_tnode *yaffs_add_find_tnode_0(struct yaffs_dev *dev,
+					struct yaffs_file_var *file_struct,
 					u32 chunk_id,
-					yaffs_tnode_t *passed_tn)
+					struct yaffs_tnode *passed_tn)
 {
 	int required_depth;
 	int i;
 	int l;
-	yaffs_tnode_t *tn;
+	struct yaffs_tnode *tn;
 
 	u32 x;
 
@@ -916,7 +917,7 @@ static int yaffs_find_chunk_in_group(struct yaffs_dev *dev, int the_chunk,
 
 static void yaffs_soft_del_chunk(struct yaffs_dev *dev, int chunk)
 {
-	yaffs_block_info_t *the_block;
+	struct yaffs_block_info *the_block;
 	unsigned block_no;
 
 	T(YAFFS_TRACE_DELETION, (TSTR("soft delete chunk %d" TENDSTR), chunk));
@@ -936,7 +937,7 @@ static void yaffs_soft_del_chunk(struct yaffs_dev *dev, int chunk)
  * Thus, essentially this is the same as DeleteWorker except that the chunks are soft deleted.
  */
 
-static int yaffs_soft_del_worker(struct yaffs_obj *in, yaffs_tnode_t *tn,
+static int yaffs_soft_del_worker(struct yaffs_obj *in, struct yaffs_tnode *tn,
 				  u32 level, int chunk_offset)
 {
 	int i;
@@ -1032,7 +1033,7 @@ static void yaffs_soft_del_file(struct yaffs_obj *obj)
  * If there is no data in a subtree then it is pruned.
  */
 
-static yaffs_tnode_t *yaffs_prune_worker(struct yaffs_dev *dev, yaffs_tnode_t *tn,
+static struct yaffs_tnode *yaffs_prune_worker(struct yaffs_dev *dev, struct yaffs_tnode *tn,
 				u32 level, int del0)
 {
 	int i;
@@ -1077,12 +1078,12 @@ static yaffs_tnode_t *yaffs_prune_worker(struct yaffs_dev *dev, yaffs_tnode_t *t
 }
 
 static int yaffs_prune_tree(struct yaffs_dev *dev,
-				yaffs_file_s *file_struct)
+				struct yaffs_file_var *file_struct)
 {
 	int i;
 	int has_data;
 	int done = 0;
-	yaffs_tnode_t *tn;
+	struct yaffs_tnode *tn;
 
 	if (file_struct->top_level > 0) {
 		file_struct->top =
@@ -1136,15 +1137,15 @@ static struct yaffs_obj *yaffs_alloc_empty_obj(struct yaffs_dev *dev)
 		obj->my_dev = dev;
 		obj->hdr_chunk = 0;
 		obj->variant_type = YAFFS_OBJECT_TYPE_UNKNOWN;
-		YINIT_LIST_HEAD(&(obj->hard_links));
-		YINIT_LIST_HEAD(&(obj->hash_link));
-		YINIT_LIST_HEAD(&obj->siblings);
+		INIT_LIST_HEAD(&(obj->hard_links));
+		INIT_LIST_HEAD(&(obj->hash_link));
+		INIT_LIST_HEAD(&obj->siblings);
 
 
 		/* Now make the directory sane */
 		if (dev->root_dir) {
 			obj->parent = dev->root_dir;
-			ylist_add(&(obj->siblings), &dev->root_dir->variant.dir_variant.children);
+			list_add(&(obj->siblings), &dev->root_dir->variant.dir_variant.children);
 		}
 
 		/* Add it to the lost and found directory.
@@ -1189,8 +1190,8 @@ static void yaffs_unhash_obj(struct yaffs_obj *obj)
 	struct yaffs_dev *dev = obj->my_dev;
 
 	/* If it is still linked into the bucket list, free from the list */
-	if (!ylist_empty(&obj->hash_link)) {
-		ylist_del_init(&obj->hash_link);
+	if (!list_empty(&obj->hash_link)) {
+		list_del_init(&obj->hash_link);
 		bucket = yaffs_hash_fn(obj->obj_id);
 		dev->obj_bucket[bucket].count--;
 	}
@@ -1207,7 +1208,7 @@ static void yaffs_free_obj(struct yaffs_obj *obj)
 		YBUG();
 	if (obj->parent)
 		YBUG();
-	if (!ylist_empty(&obj->siblings))
+	if (!list_empty(&obj->siblings))
 		YBUG();
 
 
@@ -1243,7 +1244,7 @@ static void yaffs_init_tnodes_and_objs(struct yaffs_dev *dev)
 	yaffs_init_raw_tnodes_and_objs(dev);
 
 	for (i = 0; i < YAFFS_NOBJECT_BUCKETS; i++) {
-		YINIT_LIST_HEAD(&dev->obj_bucket[i].list);
+		INIT_LIST_HEAD(&dev->obj_bucket[i].list);
 		dev->obj_bucket[i].count = 0;
 	}
 }
@@ -1281,7 +1282,7 @@ static int yaffs_new_obj_id(struct yaffs_dev *dev)
 	 */
 
 	int found = 0;
-	struct ylist_head *i;
+	struct list_head *i;
 
 	u32 n = (u32) bucket;
 
@@ -1291,9 +1292,9 @@ static int yaffs_new_obj_id(struct yaffs_dev *dev)
 		found = 1;
 		n += YAFFS_NOBJECT_BUCKETS;
 		if (1 || dev->obj_bucket[bucket].count > 0) {
-			ylist_for_each(i, &dev->obj_bucket[bucket].list) {
+			list_for_each(i, &dev->obj_bucket[bucket].list) {
 				/* If there is already one in the list */
-				if (i && ylist_entry(i, struct yaffs_obj,
+				if (i && list_entry(i, struct yaffs_obj,
 						hash_link)->obj_id == n) {
 					found = 0;
 				}
@@ -1309,20 +1310,20 @@ static void yaffs_hash_obj(struct yaffs_obj *in)
 	int bucket = yaffs_hash_fn(in->obj_id);
 	struct yaffs_dev *dev = in->my_dev;
 
-	ylist_add(&in->hash_link, &dev->obj_bucket[bucket].list);
+	list_add(&in->hash_link, &dev->obj_bucket[bucket].list);
 	dev->obj_bucket[bucket].count++;
 }
 
 struct yaffs_obj *yaffs_find_by_number(struct yaffs_dev *dev, u32 number)
 {
 	int bucket = yaffs_hash_fn(number);
-	struct ylist_head *i;
+	struct list_head *i;
 	struct yaffs_obj *in;
 
-	ylist_for_each(i, &dev->obj_bucket[bucket].list) {
+	list_for_each(i, &dev->obj_bucket[bucket].list) {
 		/* Look if it is in the list */
 		if (i) {
-			in = ylist_entry(i, struct yaffs_obj, hash_link);
+			in = list_entry(i, struct yaffs_obj, hash_link);
 			if (in->obj_id == number) {
 
 				/* Don't tell the VFS about this one if it is defered free */
@@ -1341,7 +1342,7 @@ struct yaffs_obj *yaffs_new_obj(struct yaffs_dev *dev, int number,
 				    enum yaffs_obj_type type)
 {
 	struct yaffs_obj *the_obj=NULL;
-	yaffs_tnode_t *tn = NULL;
+	struct yaffs_tnode *tn = NULL;
 
 	if (number < 0)
 		number = yaffs_new_obj_id(dev);
@@ -1367,30 +1368,20 @@ struct yaffs_obj *yaffs_new_obj(struct yaffs_dev *dev, int number,
 		the_obj->obj_id = number;
 		yaffs_hash_obj(the_obj);
 		the_obj->variant_type = type;
-#ifdef CONFIG_YAFFS_WINCE
-		yfsd_win_file_time_now(the_obj->win_atime);
-		the_obj->win_ctime[0] = the_obj->win_mtime[0] =
-		    the_obj->win_atime[0];
-		the_obj->win_ctime[1] = the_obj->win_mtime[1] =
-		    the_obj->win_atime[1];
-
-#else
+		yaffs_load_current_time(the_obj,1,1);
 
-		the_obj->yst_atime = the_obj->yst_mtime =
-		    the_obj->yst_ctime = Y_CURRENT_TIME;
-#endif
 		switch (type) {
 		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 = 0xFFFFFFFF;	/* max u32 */
+			the_obj->variant.file_variant.shrink_size = ~0;/* max */
 			the_obj->variant.file_variant.top_level = 0;
 			the_obj->variant.file_variant.top = tn;
 			break;
 		case YAFFS_OBJECT_TYPE_DIRECTORY:
-			YINIT_LIST_HEAD(&the_obj->variant.dir_variant.
+			INIT_LIST_HEAD(&the_obj->variant.dir_variant.
 					children);
-			YINIT_LIST_HEAD(&the_obj->variant.dir_variant.
+			INIT_LIST_HEAD(&the_obj->variant.dir_variant.
 					dirty);
 			break;
 		case YAFFS_OBJECT_TYPE_SYMLINK:
@@ -1492,18 +1483,8 @@ static struct yaffs_obj *yaffs_create_obj(enum yaffs_obj_type type,
 
 		in->yst_mode = mode;
 
-#ifdef CONFIG_YAFFS_WINCE
-		yfsd_win_file_time_now(in->win_atime);
-		in->win_ctime[0] = in->win_mtime[0] = in->win_atime[0];
-		in->win_ctime[1] = in->win_mtime[1] = in->win_atime[1];
+		yaffs_attribs_init(in, gid, uid, rdev);
 
-#else
-		in->yst_atime = in->yst_mtime = in->yst_ctime = Y_CURRENT_TIME;
-
-		in->yst_rdev = rdev;
-		in->yst_uid = uid;
-		in->yst_gid = gid;
-#endif
 		in->n_data_chunks = 0;
 
 		yaffs_set_obj_name(in, name);
@@ -1522,7 +1503,7 @@ static struct yaffs_obj *yaffs_create_obj(enum yaffs_obj_type type,
 				equiv_obj;
 			in->variant.hardlink_variant.equiv_id =
 				equiv_obj->obj_id;
-			ylist_add(&in->hard_links, &equiv_obj->hard_links);
+			list_add(&in->hard_links, &equiv_obj->hard_links);
 			break;
 		case YAFFS_OBJECT_TYPE_FILE:
 		case YAFFS_OBJECT_TYPE_DIRECTORY:
@@ -1665,7 +1646,7 @@ int yaffs_rename_obj(struct yaffs_obj *old_dir, const YCHAR *old_name,
 	dev = old_dir->my_dev;
 
 #ifdef CONFIG_YAFFS_CASE_INSENSITIVE
-	/* Special case for case insemsitive systems (eg. WinCE).
+	/* Special case for case insemsitive systems.
 	 * While look-up is case insensitive, the name isn't.
 	 * Therefore we might want to change x.txt to X.txt
 	*/
@@ -1686,7 +1667,7 @@ int yaffs_rename_obj(struct yaffs_obj *old_dir, const YCHAR *old_name,
 		existing_target = yaffs_find_by_name(new_dir, new_name);
 		if (existing_target &&
 			existing_target->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY &&
-			!ylist_empty(&existing_target->variant.dir_variant.children)) {
+			!list_empty(&existing_target->variant.dir_variant.children)) {
 			/* There is a target that is a non-empty directory, so we fail */
 			return YAFFS_FAIL;	/* EEXIST or ENOTEMPTY */
 		} else if (existing_target && existing_target != obj) {
@@ -1727,9 +1708,9 @@ static int yaffs_init_blocks(struct yaffs_dev *dev)
 	dev->alloc_block = -1;	/* force it to get a new one */
 
 	/* If the first allocation strategy fails, thry the alternate one */
-	dev->block_info = YMALLOC(n_blocks * sizeof(yaffs_block_info_t));
+	dev->block_info = YMALLOC(n_blocks * sizeof(struct yaffs_block_info));
 	if (!dev->block_info) {
-		dev->block_info = YMALLOC_ALT(n_blocks * sizeof(yaffs_block_info_t));
+		dev->block_info = YMALLOC_ALT(n_blocks * sizeof(struct yaffs_block_info));
 		dev->block_info_alt = 1;
 	} else
 		dev->block_info_alt = 0;
@@ -1746,7 +1727,7 @@ static int yaffs_init_blocks(struct yaffs_dev *dev)
 	}
 
 	if (dev->block_info && dev->chunk_bits) {
-		memset(dev->block_info, 0, n_blocks * sizeof(yaffs_block_info_t));
+		memset(dev->block_info, 0, n_blocks * sizeof(struct yaffs_block_info));
 		memset(dev->chunk_bits, 0, dev->chunk_bit_stride * n_blocks);
 		return YAFFS_OK;
 	}
@@ -1775,7 +1756,7 @@ static void yaffs_deinit_blocks(struct yaffs_dev *dev)
 
 void yaffs_block_became_dirty(struct yaffs_dev *dev, int block_no)
 {
-	yaffs_block_info_t *bi = yaffs_get_block_info(dev, block_no);
+	struct yaffs_block_info *bi = yaffs_get_block_info(dev, block_no);
 
 	int erased_ok = 0;
 
@@ -1852,7 +1833,7 @@ static int yaffs_find_alloc_block(struct yaffs_dev *dev)
 {
 	int i;
 
-	yaffs_block_info_t *bi;
+	struct yaffs_block_info *bi;
 
 	if (dev->n_erased_blocks < 1) {
 		/* Hoosterman we've got a problem.
@@ -1915,10 +1896,10 @@ int yaffs_check_alloc_available(struct yaffs_dev *dev, int n_chunks)
 }
 
 static int yaffs_alloc_chunk(struct yaffs_dev *dev, int use_reserver,
-		yaffs_block_info_t **block_ptr)
+		struct yaffs_block_info **block_ptr)
 {
 	int ret_val;
-	yaffs_block_info_t *bi;
+	struct yaffs_block_info *bi;
 
 	if (dev->alloc_block < 0) {
 		/* Get next block to allocate off */
@@ -1988,7 +1969,7 @@ static int yaffs_get_erased_chunks(struct yaffs_dev *dev)
 void yaffs_skip_rest_of_block(struct yaffs_dev *dev)
 {
 	if(dev->alloc_block > 0){
-		yaffs_block_info_t *bi = yaffs_get_block_info(dev, dev->alloc_block);
+		struct yaffs_block_info *bi = yaffs_get_block_info(dev, dev->alloc_block);
 		if(bi->block_state == YAFFS_BLOCK_STATE_ALLOCATING){
 			bi->block_state = YAFFS_BLOCK_STATE_FULL;
 			dev->alloc_block = -1;
@@ -2014,7 +1995,7 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block,
 
 	struct yaffs_ext_tags tags;
 
-	yaffs_block_info_t *bi = yaffs_get_block_info(dev, block);
+	struct yaffs_block_info *bi = yaffs_get_block_info(dev, block);
 
 	struct yaffs_obj *object;
 
@@ -2283,7 +2264,7 @@ static unsigned yaffs_find_gc_block(struct yaffs_dev *dev,
 	unsigned selected = 0;
 	int prioritised = 0;
 	int prioritised_exist = 0;
-	yaffs_block_info_t *bi;
+	struct yaffs_block_info *bi;
 	int threshold;
 
 	/* First let's see if we need to grab a prioritised block */
@@ -2561,7 +2542,7 @@ static 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 */
-	yaffs_tnode_t *tn;
+	struct yaffs_tnode *tn;
 	int the_chunk = -1;
 	struct yaffs_ext_tags local_tags;
 	int ret_val = -1;
@@ -2589,7 +2570,7 @@ static int yaffs_find_del_file_chunk(struct yaffs_obj *in, int inode_chunk,
 					  struct yaffs_ext_tags *tags)
 {
 	/* Get the Tnode, then get the level 0 offset chunk offset */
-	yaffs_tnode_t *tn;
+	struct yaffs_tnode *tn;
 	int the_chunk = -1;
 	struct yaffs_ext_tags local_tags;
 
@@ -2630,7 +2611,7 @@ int yaffs_put_chunk_in_file(struct yaffs_obj *in, int inode_chunk,
 	 * nand_chunk = 0 is a dummy insert to make sure the tnodes are there.
 	 */
 
-	yaffs_tnode_t *tn;
+	struct yaffs_tnode *tn;
 	struct yaffs_dev *dev = in->my_dev;
 	int existing_cunk;
 	struct yaffs_ext_tags existing_tags;
@@ -2772,7 +2753,7 @@ void yaffs_chunk_del(struct yaffs_dev *dev, int chunk_id, int mark_flash, int ly
 	int block;
 	int page;
 	struct yaffs_ext_tags tags;
-	yaffs_block_info_t *bi;
+	struct yaffs_block_info *bi;
 
 	if (chunk_id <= 0)
 		return;
@@ -2895,10 +2876,10 @@ static int yaffs_wr_data_obj(struct yaffs_obj *in, int inode_chunk,
  * If name is not NULL, then that new name is used.
  */
 int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name, int force,
-			     int is_shrink, int shadows, yaffs_xattr_mod *xmod)
+			     int is_shrink, int shadows, struct yaffs_xattr_mod *xmod)
 {
 
-	yaffs_block_info_t *bi;
+	struct yaffs_block_info *bi;
 
 	struct yaffs_dev *dev = in->my_dev;
 
@@ -2946,21 +2927,8 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name, int force,
 		oh->yst_mode = in->yst_mode;
 		oh->shadows_obj = oh->inband_shadowed_obj_id = shadows;
 
-#ifdef CONFIG_YAFFS_WINCE
-		oh->win_atime[0] = in->win_atime[0];
-		oh->win_ctime[0] = in->win_ctime[0];
-		oh->win_mtime[0] = in->win_mtime[0];
-		oh->win_atime[1] = in->win_atime[1];
-		oh->win_ctime[1] = in->win_ctime[1];
-		oh->win_mtime[1] = in->win_mtime[1];
-#else
-		oh->yst_uid = in->yst_uid;
-		oh->yst_gid = in->yst_gid;
-		oh->yst_atime = in->yst_atime;
-		oh->yst_mtime = in->yst_mtime;
-		oh->yst_ctime = in->yst_ctime;
-		oh->yst_rdev = in->yst_rdev;
-#endif
+		yaffs_load_attribs_oh(oh,in);
+
 		if (in->parent)
 			oh->parent_obj_id = in->parent->obj_id;
 		else
@@ -3069,13 +3037,13 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name, int force,
 }
 
 /*------------------------ Short Operations Cache ----------------------------------------
- *   In many situations where there is no high level buffering (eg WinCE) a lot of
+ *   In many situations where there is no high level buffering  a lot of
  *   reads might be short sequential reads, and a lot of writes may be short
  *   sequential writes. eg. scanning/writing a jpeg file.
- *   In these cases, a short read/write cache can provide a huge perfomance benefit
- *   with dumb-as-a-rock code.
- *   In Linux, the page cache provides read buffering aand the short op cache provides write
- *   buffering.
+ *   In these cases, a short read/write cache can provide a huge perfomance
+ *   benefit with dumb-as-a-rock code.
+ *   In Linux, the page cache provides read buffering and the short op cache 
+ *   provides write buffering.
  *
  *   There are a limited number (~10) of cache chunks per device so that we don't
  *   need a very intelligent search.
@@ -3085,7 +3053,7 @@ static int yaffs_obj_cache_dirty(struct yaffs_obj *obj)
 {
 	struct yaffs_dev *dev = obj->my_dev;
 	int i;
-	yaffs_cache_t *cache;
+	struct yaffs_cache *cache;
 	int n_caches = obj->my_dev->param.n_caches;
 
 	for (i = 0; i < n_caches; i++) {
@@ -3104,7 +3072,7 @@ static void yaffs_flush_file_cache(struct yaffs_obj *obj)
 	struct yaffs_dev *dev = obj->my_dev;
 	int lowest = -99;	/* Stop compiler whining. */
 	int i;
-	yaffs_cache_t *cache;
+	struct yaffs_cache *cache;
 	int chunk_written = 0;
 	int n_caches = obj->my_dev->param.n_caches;
 
@@ -3185,7 +3153,7 @@ void yaffs_flush_whole_cache(struct yaffs_dev *dev)
  * Then look for the least recently used non-dirty one.
  * Then look for the least recently used dirty one...., flush and look again.
  */
-static yaffs_cache_t *yaffs_grab_chunk_worker(struct yaffs_dev *dev)
+static struct yaffs_cache *yaffs_grab_chunk_worker(struct yaffs_dev *dev)
 {
 	int i;
 
@@ -3199,9 +3167,9 @@ static yaffs_cache_t *yaffs_grab_chunk_worker(struct yaffs_dev *dev)
 	return NULL;
 }
 
-static yaffs_cache_t *yaffs_grab_chunk_cache(struct yaffs_dev *dev)
+static struct yaffs_cache *yaffs_grab_chunk_cache(struct yaffs_dev *dev)
 {
-	yaffs_cache_t *cache;
+	struct yaffs_cache *cache;
 	struct yaffs_obj *the_obj;
 	int usage;
 	int i;
@@ -3251,7 +3219,7 @@ static yaffs_cache_t *yaffs_grab_chunk_cache(struct yaffs_dev *dev)
 }
 
 /* Find a cached chunk */
-static yaffs_cache_t *yaffs_find_chunk_cache(const struct yaffs_obj *obj,
+static struct yaffs_cache *yaffs_find_chunk_cache(const struct yaffs_obj *obj,
 					      int chunk_id)
 {
 	struct yaffs_dev *dev = obj->my_dev;
@@ -3270,7 +3238,7 @@ static yaffs_cache_t *yaffs_find_chunk_cache(const struct yaffs_obj *obj,
 }
 
 /* Mark the chunk for the least recently used algorithym */
-static void yaffs_use_cache(struct yaffs_dev *dev, yaffs_cache_t *cache,
+static void yaffs_use_cache(struct yaffs_dev *dev, struct yaffs_cache *cache,
 				int is_write)
 {
 
@@ -3300,7 +3268,7 @@ static void yaffs_use_cache(struct yaffs_dev *dev, yaffs_cache_t *cache,
 static void yaffs_invalidate_chunk_cache(struct yaffs_obj *object, int chunk_id)
 {
 	if (object->my_dev->param.n_caches > 0) {
-		yaffs_cache_t *cache = yaffs_find_chunk_cache(object, chunk_id);
+		struct yaffs_cache *cache = yaffs_find_chunk_cache(object, chunk_id);
 
 		if (cache)
 			cache->object = NULL;
@@ -3344,7 +3312,7 @@ int yaffs_file_rd(struct yaffs_obj *in, u8 *buffer, loff_t offset,
 	int n_copy;
 	int n = n_bytes;
 	int n_done = 0;
-	yaffs_cache_t *cache;
+	struct yaffs_cache *cache;
 
 	struct yaffs_dev *dev;
 
@@ -3497,7 +3465,7 @@ int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset,
 			 * or we're using inband tags, so we want to use the cache buffers.
 			 */
 			if (dev->param.n_caches > 0) {
-				yaffs_cache_t *cache;
+				struct yaffs_cache *cache;
 				/* If we can't find the data in the cache, then load the cache */
 				cache = yaffs_find_chunk_cache(in, chunk);
 
@@ -3726,25 +3694,6 @@ int yaffs_resize_file(struct yaffs_obj *in, loff_t new_size)
 	return YAFFS_OK;
 }
 
-loff_t yaffs_get_file_size(struct yaffs_obj *obj)
-{
-	YCHAR *alias = NULL;
-	obj = yaffs_get_equivalent_obj(obj);
-
-	switch (obj->variant_type) {
-	case YAFFS_OBJECT_TYPE_FILE:
-		return obj->variant.file_variant.file_size;
-	case YAFFS_OBJECT_TYPE_SYMLINK:
-		alias = obj->variant.symlink_variant.alias;
-		if(!alias)
-			return 0;
-		return yaffs_strnlen(alias,YAFFS_MAX_ALIAS_LENGTH);
-	default:
-		return 0;
-	}
-}
-
-
 
 int yaffs_flush_file(struct yaffs_obj *in, int update_time, int data_sync)
 {
@@ -3754,15 +3703,8 @@ int yaffs_flush_file(struct yaffs_obj *in, int update_time, int data_sync)
 		if(data_sync) /* Only sync data */
 			ret_val=YAFFS_OK;
 		else {
-			if (update_time) {
-#ifdef CONFIG_YAFFS_WINCE
-				yfsd_win_file_time_now(in->win_mtime);
-#else
-
-				in->yst_mtime = Y_CURRENT_TIME;
-
-#endif
-			}
+			if (update_time)
+				yaffs_load_current_time(in,0,0);
 
 			ret_val = (yaffs_update_oh(in, NULL, 0, 0, 0, NULL) >=
 				0) ? YAFFS_OK : YAFFS_FAIL;
@@ -3870,7 +3812,7 @@ int yaffs_del_file(struct yaffs_obj *in)
 static int yaffs_is_non_empty_dir(struct yaffs_obj *obj)
 {
 	return (obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) &&
-		!(ylist_empty(&obj->variant.dir_variant.children));
+		!(list_empty(&obj->variant.dir_variant.children));
 }
 
 static int yaffs_del_dir(struct yaffs_obj *obj)
@@ -3896,7 +3838,7 @@ static int yaffs_del_link(struct yaffs_obj *in)
 	/* remove this hardlink from the list assocaited with the equivalent
 	 * object
 	 */
-	ylist_del_init(&in->hard_links);
+	list_del_init(&in->hard_links);
 	return yaffs_generic_obj_del(in);
 }
 
@@ -3908,9 +3850,9 @@ int ret_val = -1;
 		ret_val = yaffs_del_file(obj);
 		break;
 	case YAFFS_OBJECT_TYPE_DIRECTORY:
-		if(!ylist_empty(&obj->variant.dir_variant.dirty)){
+		if(!list_empty(&obj->variant.dir_variant.dirty)){
 			T(YAFFS_TRACE_BACKGROUND, (TSTR("Remove object %d from dirty directories" TENDSTR),obj->obj_id));
-			ylist_del_init(&obj->variant.dir_variant.dirty);
+			list_del_init(&obj->variant.dir_variant.dirty);
 		}
 		return yaffs_del_dir(obj);
 		break;
@@ -3944,7 +3886,7 @@ static int yaffs_unlink_worker(struct yaffs_obj *obj)
 
 	if (obj->variant_type == YAFFS_OBJECT_TYPE_HARDLINK) {
 		return yaffs_del_link(obj);
-	} else if (!ylist_empty(&obj->hard_links)) {
+	} else if (!list_empty(&obj->hard_links)) {
 		/* Curve ball: We're unlinking an object that has a hardlink.
 		 *
 		 * This problem arises because we are not strictly following
@@ -3964,12 +3906,12 @@ static int yaffs_unlink_worker(struct yaffs_obj *obj)
 		int ret_val;
 		YCHAR name[YAFFS_MAX_NAME_LENGTH + 1];
 
-		hl = ylist_entry(obj->hard_links.next, struct yaffs_obj, hard_links);
+		hl = list_entry(obj->hard_links.next, struct yaffs_obj, hard_links);
 
 		yaffs_get_obj_name(hl, name, YAFFS_MAX_NAME_LENGTH + 1);
 		parent = hl->parent;
 
-		ylist_del_init(&hl->hard_links);
+		list_del_init(&hl->hard_links);
 
  		yaffs_add_obj_to_dir(obj->my_dev->unlinked_dir, hl);
 
@@ -3986,7 +3928,7 @@ static int yaffs_unlink_worker(struct yaffs_obj *obj)
 			return yaffs_del_file(obj);
 			break;
 		case YAFFS_OBJECT_TYPE_DIRECTORY:
-			ylist_del_init(&obj->variant.dir_variant.dirty);
+			list_del_init(&obj->variant.dir_variant.dirty);
 			return yaffs_del_dir(obj);
 			break;
 		case YAFFS_OBJECT_TYPE_SYMLINK:
@@ -4078,13 +4020,13 @@ void yaffs_link_fixup(struct yaffs_dev *dev, struct yaffs_obj *hard_list)
 		if (in) {
 			/* Add the hardlink pointers */
 			hl->variant.hardlink_variant.equiv_obj = in;
-			ylist_add(&hl->hard_links, &in->hard_links);
+			list_add(&hl->hard_links, &in->hard_links);
 		} else {
 			/* Todo Need to report/handle this better.
 			 * Got a problem... hardlink to a non-existant object
 			 */
 			hl->variant.hardlink_variant.equiv_obj = NULL;
-			YINIT_LIST_HEAD(&hl->hard_links);
+			INIT_LIST_HEAD(&hl->hard_links);
 
 		}
 	}
@@ -4096,26 +4038,26 @@ static void yaffs_strip_deleted_objs(struct yaffs_dev *dev)
 	/*
 	*  Sort out state of unlinked and deleted objects after scanning.
 	*/
-	struct ylist_head *i;
-	struct ylist_head *n;
+	struct list_head *i;
+	struct list_head *n;
 	struct yaffs_obj *l;
 
 	if (dev->read_only)
 		return;
 
 	/* Soft delete all the unlinked files */
-	ylist_for_each_safe(i, n,
+	list_for_each_safe(i, n,
 		&dev->unlinked_dir->variant.dir_variant.children) {
 		if (i) {
-			l = ylist_entry(i, struct yaffs_obj, siblings);
+			l = list_entry(i, struct yaffs_obj, siblings);
 			yaffs_del_obj(l);
 		}
 	}
 
-	ylist_for_each_safe(i, n,
+	list_for_each_safe(i, n,
 		&dev->del_dir->variant.dir_variant.children) {
 		if (i) {
-			l = ylist_entry(i, struct yaffs_obj, siblings);
+			l = list_entry(i, struct yaffs_obj, siblings);
 			yaffs_del_obj(l);
 		}
 	}
@@ -4151,8 +4093,8 @@ static void yaffs_fix_hanging_objs(struct yaffs_dev *dev)
 	struct yaffs_obj *obj;
 	struct yaffs_obj *parent;
 	int i;
-	struct ylist_head *lh;
-	struct ylist_head *n;
+	struct list_head *lh;
+	struct list_head *n;
 	int depth_limit;
 	int hanging;
 
@@ -4165,9 +4107,9 @@ static void yaffs_fix_hanging_objs(struct yaffs_dev *dev)
 	 */
 
 	for (i = 0; i <  YAFFS_NOBJECT_BUCKETS; i++) {
-		ylist_for_each_safe(lh, n, &dev->obj_bucket[i].list) {
+		list_for_each_safe(lh, n, &dev->obj_bucket[i].list) {
 			if (lh) {
-				obj = ylist_entry(lh, struct yaffs_obj, hash_link);
+				obj = list_entry(lh, struct yaffs_obj, hash_link);
 				parent= obj->parent;
 				
 				if(yaffs_has_null_parent(dev,obj)){
@@ -4213,15 +4155,15 @@ static void yaffs_fix_hanging_objs(struct yaffs_dev *dev)
 static void yaffs_del_dir_contents(struct yaffs_obj *dir)
 {
 	struct yaffs_obj *obj;
-	struct ylist_head *lh;
-	struct ylist_head *n;
+	struct list_head *lh;
+	struct list_head *n;
 
 	if(dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY)
 		YBUG();
 	
-	ylist_for_each_safe(lh, n, &dir->variant.dir_variant.children) {
+	list_for_each_safe(lh, n, &dir->variant.dir_variant.children) {
 		if (lh) {
-			obj = ylist_entry(lh, struct yaffs_obj, siblings);
+			obj = list_entry(lh, struct yaffs_obj, siblings);
 			if(obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY)
 				yaffs_del_dir_contents(obj);
 
@@ -4265,22 +4207,7 @@ static void yaffs_check_obj_details_loaded(struct yaffs_obj *in)
 		oh = (struct yaffs_obj_hdr *) chunk_data;
 
 		in->yst_mode = oh->yst_mode;
-#ifdef CONFIG_YAFFS_WINCE
-		in->win_atime[0] = oh->win_atime[0];
-		in->win_ctime[0] = oh->win_ctime[0];
-		in->win_mtime[0] = oh->win_mtime[0];
-		in->win_atime[1] = oh->win_atime[1];
-		in->win_ctime[1] = oh->win_ctime[1];
-		in->win_mtime[1] = oh->win_mtime[1];
-#else
-		in->yst_uid = oh->yst_uid;
-		in->yst_gid = oh->yst_gid;
-		in->yst_atime = oh->yst_atime;
-		in->yst_mtime = oh->yst_mtime;
-		in->yst_ctime = oh->yst_ctime;
-		in->yst_rdev = oh->yst_rdev;
-
-#endif
+		yaffs_load_attribs(in, oh);
 		yaffs_set_obj_name_from_oh(in, oh);
 
 		if (in->variant_type == YAFFS_OBJECT_TYPE_SYMLINK) {
@@ -4317,40 +4244,39 @@ static void yaffs_update_parent(struct yaffs_obj *obj)
 	struct yaffs_dev *dev;
 	if(!obj)
 		return;
-#ifndef CONFIG_YAFFS_WINCE
-
 	dev = obj->my_dev;
 	obj->dirty = 1;
-	obj->yst_mtime = obj->yst_ctime = Y_CURRENT_TIME;
+	yaffs_load_current_time(obj,0,1);
 	if(dev->param.defered_dir_update){
-		struct ylist_head *link = &obj->variant.dir_variant.dirty; 
+		struct list_head *link = &obj->variant.dir_variant.dirty; 
 	
-		if(ylist_empty(link)){
-			ylist_add(link,&dev->dirty_dirs);
-			T(YAFFS_TRACE_BACKGROUND, (TSTR("Added object %d to dirty directories" TENDSTR),obj->obj_id));
+		if(list_empty(link)){
+			list_add(link,&dev->dirty_dirs);
+			T(YAFFS_TRACE_BACKGROUND, 
+			(TSTR("Added object %d to dirty directories" TENDSTR),
+			obj->obj_id));
 		}
 
 	} else
 		yaffs_update_oh(obj, NULL, 0, 0, 0, NULL);
-#endif
 }
 
 void yaffs_update_dirty_dirs(struct yaffs_dev *dev)
 {
-	struct ylist_head *link;
+	struct list_head *link;
 	struct yaffs_obj *obj;
-	yaffs_dir_s *d_s;
-	yaffs_obj_variant *o_v;
+	struct yaffs_dir_var *d_s;
+	union yaffs_obj_var *o_v;
 
 	T(YAFFS_TRACE_BACKGROUND, (TSTR("Update dirty directories" TENDSTR)));
 
-	while(!ylist_empty(&dev->dirty_dirs)){
+	while(!list_empty(&dev->dirty_dirs)){
 		link = dev->dirty_dirs.next;
-		ylist_del_init(link);
+		list_del_init(link);
 		
-		d_s=ylist_entry(link,yaffs_dir_s,dirty);
-		o_v = ylist_entry(d_s,yaffs_obj_variant,dir_variant);
-		obj = ylist_entry(o_v,struct yaffs_obj,variant);
+		d_s=list_entry(link,struct yaffs_dir_var,dirty);
+		o_v = list_entry(d_s,union yaffs_obj_var,dir_variant);
+		obj = list_entry(o_v,struct yaffs_obj,variant);
 
 		T(YAFFS_TRACE_BACKGROUND, (TSTR("Update directory %d" TENDSTR), obj->obj_id));
 
@@ -4373,7 +4299,7 @@ static void yaffs_remove_obj_from_dir(struct yaffs_obj *obj)
 		dev->param.remove_obj_fn(obj);
 
 
-	ylist_del_init(&obj->siblings);
+	list_del_init(&obj->siblings);
 	obj->parent = NULL;
 	
 	yaffs_verify_dir(parent);
@@ -4410,7 +4336,7 @@ void yaffs_add_obj_to_dir(struct yaffs_obj *directory,
 
 
 	/* Now add it */
-	ylist_add(&obj->siblings, &directory->variant.dir_variant.children);
+	list_add(&obj->siblings, &directory->variant.dir_variant.children);
 	obj->parent = directory;
 
 	if (directory == obj->my_dev->unlinked_dir
@@ -4429,7 +4355,7 @@ struct yaffs_obj *yaffs_find_by_name(struct yaffs_obj *directory,
 {
 	int sum;
 
-	struct ylist_head *i;
+	struct list_head *i;
 	YCHAR buffer[YAFFS_MAX_NAME_LENGTH + 1];
 
 	struct yaffs_obj *l;
@@ -4454,9 +4380,9 @@ struct yaffs_obj *yaffs_find_by_name(struct yaffs_obj *directory,
 
 	sum = yaffs_calc_name_sum(name);
 
-	ylist_for_each(i, &directory->variant.dir_variant.children) {
+	list_for_each(i, &directory->variant.dir_variant.children) {
 		if (i) {
-			l = ylist_entry(i, struct yaffs_obj, siblings);
+			l = list_entry(i, struct yaffs_obj, siblings);
 
 			if (l->parent != directory)
 				YBUG();
@@ -4658,12 +4584,12 @@ int yaffs_get_obj_length(struct yaffs_obj *obj)
 int yaffs_get_obj_link_count(struct yaffs_obj *obj)
 {
 	int count = 0;
-	struct ylist_head *i;
+	struct list_head *i;
 
 	if (!obj->unlinked)
 		count++;		/* the object itself */
 
-	ylist_for_each(i, &obj->hard_links)
+	list_for_each(i, &obj->hard_links)
 		count++;		/* add the hard links; */
 
 	return count;
@@ -4717,66 +4643,9 @@ YCHAR *yaffs_get_symlink_alias(struct yaffs_obj *obj)
 		return yaffs_clone_str(_Y(""));
 }
 
-#ifndef CONFIG_YAFFS_WINCE
-
-int yaffs_set_attribs(struct yaffs_obj *obj, struct iattr *attr)
-{
-	unsigned int valid = attr->ia_valid;
-
-	if (valid & ATTR_MODE)
-		obj->yst_mode = attr->ia_mode;
-	if (valid & ATTR_UID)
-		obj->yst_uid = attr->ia_uid;
-	if (valid & ATTR_GID)
-		obj->yst_gid = attr->ia_gid;
-
-	if (valid & ATTR_ATIME)
-		obj->yst_atime = Y_TIME_CONVERT(attr->ia_atime);
-	if (valid & ATTR_CTIME)
-		obj->yst_ctime = Y_TIME_CONVERT(attr->ia_ctime);
-	if (valid & ATTR_MTIME)
-		obj->yst_mtime = Y_TIME_CONVERT(attr->ia_mtime);
-
-	if (valid & ATTR_SIZE)
-		yaffs_resize_file(obj, attr->ia_size);
-
-	yaffs_update_oh(obj, NULL, 1, 0, 0, NULL);
-
-	return YAFFS_OK;
-
-}
-int yaffs_get_attribs(struct yaffs_obj *obj, struct iattr *attr)
-{
-	unsigned int valid = 0;
-
-	attr->ia_mode = obj->yst_mode;
-	valid |= ATTR_MODE;
-	attr->ia_uid = obj->yst_uid;
-	valid |= ATTR_UID;
-	attr->ia_gid = obj->yst_gid;
-	valid |= ATTR_GID;
-
-	Y_TIME_CONVERT(attr->ia_atime) = obj->yst_atime;
-	valid |= ATTR_ATIME;
-	Y_TIME_CONVERT(attr->ia_ctime) = obj->yst_ctime;
-	valid |= ATTR_CTIME;
-	Y_TIME_CONVERT(attr->ia_mtime) = obj->yst_mtime;
-	valid |= ATTR_MTIME;
-
-	attr->ia_size = yaffs_get_file_size(obj);
-	valid |= ATTR_SIZE;
-
-	attr->ia_valid = valid;
-
-	return YAFFS_OK;
-}
-
-#endif
-
-
 static int yaffs_do_xattrib_mod(struct yaffs_obj *obj, int set, const YCHAR *name, const void *value, int size, int flags)
 {
-	yaffs_xattr_mod xmod;
+	struct yaffs_xattr_mod xmod;
 
 	int result;
 
@@ -4795,7 +4664,7 @@ static int yaffs_do_xattrib_mod(struct yaffs_obj *obj, int set, const YCHAR *nam
 		return -ENOSPC;
 }
 
-static int yaffs_apply_xattrib_mod(struct yaffs_obj *obj, char *buffer, yaffs_xattr_mod *xmod)
+static int yaffs_apply_xattrib_mod(struct yaffs_obj *obj, char *buffer, struct yaffs_xattr_mod *xmod)
 {
 	int retval = 0;
 	int x_offs = sizeof(struct yaffs_obj_hdr);
@@ -5006,7 +4875,7 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
 
 	/* Sort out space for inband tags, if required */
 	if (dev->param.inband_tags)
-		dev->data_bytes_per_chunk = dev->param.total_bytes_per_chunk - sizeof(yaffs_packed_tags2_tags_only);
+		dev->data_bytes_per_chunk = dev->param.total_bytes_per_chunk - sizeof(struct yaffs_packed_tags2_tags_only);
 	else
 		dev->data_bytes_per_chunk = dev->param.total_bytes_per_chunk;
 
@@ -5020,13 +4889,6 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
 		return YAFFS_FAIL;
 	}
 
-	/* This is really a compilation check. */
-	if (!yaffs_check_structures()) {
-		T(YAFFS_TRACE_ALWAYS,
-		  (TSTR("yaffs_check_structures failed\n" TENDSTR)));
-		return YAFFS_FAIL;
-	}
-
 	if (dev->is_mounted) {
 		T(YAFFS_TRACE_ALWAYS,
 		  (TSTR("yaffs: device already mounted\n" TENDSTR)));
@@ -5085,8 +4947,8 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
 		dev->chunk_grp_bits = bits - dev->tnode_width;
 
 	dev->tnode_size = (dev->tnode_width * YAFFS_NTNODES_LEVEL0)/8;
-	if(dev->tnode_size < sizeof(yaffs_tnode_t))
-		dev->tnode_size = sizeof(yaffs_tnode_t);
+	if(dev->tnode_size < sizeof(struct yaffs_tnode))
+		dev->tnode_size = sizeof(struct yaffs_tnode);
 
 	dev->chunk_grp_size = 1 << dev->chunk_grp_bits;
 
@@ -5122,7 +4984,7 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
 	dev->n_erased_blocks = 0;
 	dev->gc_disable= 0;
 	dev->has_pending_prioritised_gc = 1; /* Assume the worst for now, will get fixed on first GC */
-	YINIT_LIST_HEAD(&dev->dirty_dirs);
+	INIT_LIST_HEAD(&dev->dirty_dirs);
 	dev->oldest_dirty_seq = 0;
 	dev->oldest_dirty_block = 0;
 
@@ -5138,7 +5000,7 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
 	    dev->param.n_caches > 0) {
 		int i;
 		void *buf;
-		int cache_bytes = dev->param.n_caches * sizeof(yaffs_cache_t);
+		int cache_bytes = dev->param.n_caches * sizeof(struct yaffs_cache);
 
 		if (dev->param.n_caches > YAFFS_MAX_SHORT_OP_CACHES)
 			dev->param.n_caches = YAFFS_MAX_SHORT_OP_CACHES;
@@ -5294,7 +5156,7 @@ int yaffs_count_free_chunks(struct yaffs_dev *dev)
 	int n_free=0;
 	int b;
 
-	yaffs_block_info_t *blk;
+	struct yaffs_block_info *blk;
 
 	blk = dev->block_info;
 	for (b = dev->internal_start_block; b <= dev->internal_end_block; b++) {
@@ -5350,28 +5212,3 @@ int yaffs_get_n_free_chunks(struct yaffs_dev *dev)
 	return n_free;
 
 }
-
-
-/*---------------------------------------- YAFFS test code ----------------------*/
-
-#define yaffs_check_struct(structure, syze, name) \
-	do { \
-		if (sizeof(structure) != syze) { \
-			T(YAFFS_TRACE_ALWAYS, (TSTR("%s should be %d but is %d\n" TENDSTR),\
-				name, syze, (int) sizeof(structure))); \
-			return YAFFS_FAIL; \
-		} \
-	} while (0)
-
-static int yaffs_check_structures(void)
-{
-/*      yaffs_check_struct(struct yaffs_tags,8,"struct yaffs_tags"); */
-/*      yaffs_check_struct(yaffs_tags_union_t,8,"yaffs_tags_union_t"); */
-/*      yaffs_check_struct(yaffs_spare,16,"yaffs_spare"); */
-/*	yaffs_check_struct(yaffs_tnode_t, 2 * YAFFS_NTNODES_LEVEL0, "yaffs_tnode_t"); */
-
-#ifndef CONFIG_YAFFS_WINCE
-	yaffs_check_struct(struct yaffs_obj_hdr, 512, "struct yaffs_obj_hdr");
-#endif
-	return YAFFS_OK;
-}