yaffs: Remove a whole lot of function wrappers and forward declarations

Signed-off-by: Charles Manning <cdhmanning@gmail.com>

21 files changed, 2383 insertions, 2584 deletions

diff --git a/direct/basic-test/yaffs_ramdisk.c b/direct/basic-test/yaffs_ramdisk.c
index babddde..88fc3a4 100644
--- a/direct/basic-test/yaffs_ramdisk.c
+++ b/direct/basic-test/yaffs_ramdisk.c
@@ -79,7 +79,7 @@ static int  CheckInit(struct yaffs_dev *dev)
 	
 	ramdisk.nBlocks = (SIZE_IN_MB * 1024 * 1024)/(16 * 1024);
 	
-	ramdisk.block = YMALLOC(sizeof(yramdisk_block *) * ramdisk.nBlocks);
+	ramdisk.block = malloc(sizeof(yramdisk_block *) * ramdisk.nBlocks);
 	
 	if(!ramdisk.block) return 0;
 	
@@ -90,7 +90,7 @@ static int  CheckInit(struct yaffs_dev *dev)
 	
 	for(i=0; i <ramdisk.nBlocks && !fail; i++)
 	{
-		if((ramdisk.block[i] = YMALLOC(sizeof(yramdisk_block))) == 0)
+		if((ramdisk.block[i] = malloc(sizeof(yramdisk_block))) == 0)
 		{
 			fail = 1;
 		}
@@ -105,9 +105,9 @@ static int  CheckInit(struct yaffs_dev *dev)
 	{
 		for(i = 0; i < nAllocated; i++)
 		{
-			YFREE(ramdisk.block[i]);
+			kfree(ramdisk.block[i]);
 		}
-		YFREE(ramdisk.block);
+		kfree(ramdisk.block);
 		
 		T(YAFFS_TRACE_ALWAYS,("Allocation failed, could only allocate %dMB of %dMB requested.\n",
 		   nAllocated/64,ramdisk.nBlocks * 528));
diff --git a/direct/basic-test/yaffs_ramem2k.c b/direct/basic-test/yaffs_ramem2k.c
index 7f88b7c..9a857fd 100644
--- a/direct/basic-test/yaffs_ramem2k.c
+++ b/direct/basic-test/yaffs_ramem2k.c
@@ -135,7 +135,7 @@ static int  CheckInit(void)
 	ned.nBlocks = nBlocks = nandemul2k_CalcNBlocks();
 
 	
-	ned.block = YMALLOC(sizeof(nandemul_Block*) * nBlocks );
+	ned.block = malloc(sizeof(nandemul_Block*) * nBlocks );
 	
 	if(!ned.block) return YAFFS_FAIL;
 	
@@ -148,7 +148,7 @@ static int  CheckInit(void)
 		
 		nandemul_Block *blk;
 		
-		if(!(blk = ned.block[i] = YMALLOC(sizeof(nandemul_Block))))
+		if(!(blk = ned.block[i] = malloc(sizeof(nandemul_Block))))
 		{
 		 fail = 1;
 		}  
@@ -156,7 +156,7 @@ static int  CheckInit(void)
 		{
 			for(j = 0; j < PAGES_PER_BLOCK; j++)
 			{
-				if((blk->page[j] = YMALLOC(sizeof(nandemul_Page))) == 0)
+				if((blk->page[j] = malloc(sizeof(nandemul_Page))) == 0)
 				{
 					fail = 1;
 				}
@@ -173,9 +173,9 @@ static int  CheckInit(void)
 		
 		for(i = 0; i < nAllocated; i++)
 		{
-			YFREE(ned.block[i]);
+			kfree(ned.block[i]);
 		}
-		YFREE(ned.block);
+		kfree(ned.block);
 		
 		T(YAFFS_TRACE_ALWAYS,("Allocation failed, could only allocate %dMB of %dMB requested.\n",
 		   nAllocated/64,sizeInMB));
diff --git a/direct/basic-test/yramsim.c b/direct/basic-test/yramsim.c
index 9b50a39..1fbf5fe 100644
--- a/direct/basic-test/yramsim.c
+++ b/direct/basic-test/yramsim.c
@@ -260,11 +260,11 @@ struct yaffs_dev *yramsim_CreateRamSim(const YCHAR *name,
 
 	sim = yramsim_alloc_sim_data(devId, nBlocks);
 
-	g = YMALLOC(sizeof(ynandif_Geometry));
+	g = malloc(sizeof(ynandif_Geometry));
 
 	if(!sim || !g){
 		if(g)
-			YFREE(g);
+			free(g);
 		return NULL;
 	}
 
diff --git a/direct/yaffs_attribs.c b/direct/yaffs_attribs.c
index 89cd7fc..86e5e6e 100644
--- a/direct/yaffs_attribs.c
+++ b/direct/yaffs_attribs.c
@@ -92,7 +92,7 @@ loff_t yaffs_get_file_size(struct yaffs_obj *obj)
 		alias = obj->variant.symlink_variant.alias;
 		if(!alias)
 			return 0;
-		return yaffs_strnlen(alias,YAFFS_MAX_ALIAS_LENGTH);
+		return strnlen(alias,YAFFS_MAX_ALIAS_LENGTH);
 	default:
 		return 0;
 	}
diff --git a/direct/yaffs_flashif.c b/direct/yaffs_flashif.c
index 8595804..95ac613 100644
--- a/direct/yaffs_flashif.c
+++ b/direct/yaffs_flashif.c
@@ -67,7 +67,7 @@ static int  CheckInit(struct yaffs_dev *dev)
 	
 	ramdisk.nBlocks = (SIZE_IN_MB * 1024 * 1024)/(16 * 1024);
 	
-	ramdisk.block = YMALLOC(sizeof(yflash_Block *) * ramdisk.nBlocks);
+	ramdisk.block = kmalloc(sizeof(yflash_Block *) * ramdisk.nBlocks);
 	
 	if(!ramdisk.block) return 0;
 	
@@ -78,7 +78,7 @@ static int  CheckInit(struct yaffs_dev *dev)
 	
 	for(i=0; i <ramdisk.nBlocks && !fail; i++)
 	{
-		if((ramdisk.block[i] = YMALLOC(sizeof(yflash_Block))) == 0)
+		if((ramdisk.block[i] = kmalloc(sizeof(yflash_Block))) == 0)
 		{
 			fail = 1;
 		}
@@ -93,9 +93,9 @@ static int  CheckInit(struct yaffs_dev *dev)
 	{
 		for(i = 0; i < nAllocated; i++)
 		{
-			YFREE(ramdisk.block[i]);
+			kfree(ramdisk.block[i]);
 		}
-		YFREE(ramdisk.block);
+		kfree(ramdisk.block);
 		
 		T(YAFFS_TRACE_ALWAYS,("Allocation failed, could only allocate %dMB of %dMB requested.\n",
 		   nAllocated/64,ramdisk.nBlocks * YAFFS_BYTES_PER_BLOCK));
diff --git a/direct/yaffs_nandif.c b/direct/yaffs_nandif.c
index 9a22f7f..f2806e1 100644
--- a/direct/yaffs_nandif.c
+++ b/direct/yaffs_nandif.c
@@ -215,12 +215,12 @@ struct yaffs_dev *
 	yaffs_add_dev_from_geometry(const YCHAR *name,
 					const ynandif_Geometry *geometry)
 {
-	YCHAR *clonedName = YMALLOC(sizeof(YCHAR) * (yaffs_strnlen(name,YAFFS_MAX_NAME_LENGTH)+1));
-	struct yaffs_dev *dev = YMALLOC(sizeof(struct yaffs_dev));
+	YCHAR *clonedName = malloc(sizeof(YCHAR) * (strnlen(name,YAFFS_MAX_NAME_LENGTH)+1));
+	struct yaffs_dev *dev = malloc(sizeof(struct yaffs_dev));
 
 	if(dev && clonedName){
 		memset(dev,0,sizeof(struct yaffs_dev));
-		yaffs_strcpy(clonedName,name);
+		strcpy(clonedName,name);
 
 		dev->param.name = clonedName;
 		dev->param.write_chunk_tags_fn  = ynandif_WriteChunkWithTagsToNAND;
@@ -247,9 +247,9 @@ struct yaffs_dev *
 	}
 
 	if(dev)
-		YFREE(dev);
+		free(dev);
 	if(clonedName)
-		YFREE(clonedName);
+		free(clonedName);
 
 	return NULL;
 }
diff --git a/direct/yaffsfs.c b/direct/yaffsfs.c
index 64bd94f..a9c6b43 100644
--- a/direct/yaffsfs.c
+++ b/direct/yaffsfs.c
@@ -405,7 +405,7 @@ int yaffsfs_CheckNameLength(const char *name)
 {
 	int retVal = 0;		
 
-	int nameLength = yaffs_strnlen(name,YAFFS_MAX_NAME_LENGTH+1);
+	int nameLength = strnlen(name,YAFFS_MAX_NAME_LENGTH+1);
 		
 	if(nameLength == 0){
 		yaffsfs_SetError(-ENOENT);
@@ -440,7 +440,7 @@ static int yaffsfs_alt_dir_path(const YCHAR *path, YCHAR **ret_path)
 	 */
 	if(path_length > 0 && 
 		yaffsfs_IsPathDivider(path[path_length-1])){
-		alt_path = YMALLOC(path_length + 1);
+		alt_path = kmalloc(path_length + 1, 0);
 		if(!alt_path)
 			return -1;
 		strcpy(alt_path, path);
@@ -650,11 +650,11 @@ static struct yaffs_obj *yaffsfs_DoFindDirectory(struct yaffs_obj *startDir,
 			/* got to the end of the string */
 			return dir;
 		else{
-			if(yaffs_strcmp(str,_Y(".")) == 0)
+			if(strcmp(str,_Y(".")) == 0)
 			{
 				/* Do nothing */
 			}
-			else if(yaffs_strcmp(str,_Y("..")) == 0)
+			else if(strcmp(str,_Y("..")) == 0)
 				dir = dir->parent;
 			else{
 				dir = yaffs_find_by_name(dir,str);
@@ -1421,7 +1421,7 @@ int yaffsfs_DoUnlink(const YCHAR *path,int isDirectory)
 		yaffsfs_SetError(-ELOOP);
 	else if(!dir)
 		yaffsfs_SetError(-ENOENT);
-	else if(yaffs_strncmp(name,_Y("."),2) == 0)
+	else if(strncmp(name,_Y("."),2) == 0)
 		yaffsfs_SetError(-EINVAL);
 	else if(!obj)
 		yaffsfs_SetError(-ENOENT);
@@ -1509,7 +1509,7 @@ int yaffs_rename(const YCHAR *oldPath, const YCHAR *newPath)
 	} else if(oldLoop || newLoop) {
 		yaffsfs_SetError(-ELOOP);
 		rename_allowed = 0;
-	} else if (olddir && oldname && yaffs_strncmp(oldname, _Y("."),2) == 0){
+	} else if (olddir && oldname && strncmp(oldname, _Y("."),2) == 0){
 		yaffsfs_SetError(-EINVAL);
 		rename_allowed = 0;
 	}else if(!olddir || !newdir || !obj) {
@@ -1550,7 +1550,7 @@ int yaffs_rename(const YCHAR *oldPath, const YCHAR *newPath)
 	yaffsfs_Unlock();
 
 	if(alt_newpath)
-		YFREE(alt_newpath);
+		kfree(alt_newpath);
 
 	return (result == YAFFS_FAIL) ? -1 : 0;
 }
@@ -2279,7 +2279,7 @@ int yaffs_mkdir(const YCHAR *path, mode_t mode)
 		yaffsfs_SetError(-ELOOP);
 	else if(!parent)
 		yaffsfs_SetError(-ENOENT);
-	else if(yaffs_strnlen(name,5) == 0){
+	else if(strnlen(name,5) == 0){
 		/* Trying to make the root itself */
 		yaffsfs_SetError(-EEXIST);
 	} else if(parent->my_dev->read_only)
@@ -2297,7 +2297,7 @@ int yaffs_mkdir(const YCHAR *path, mode_t mode)
 	yaffsfs_Unlock();
 
 	if(alt_path)
-		YFREE(alt_path);
+		kfree(alt_path);
 
 	return retVal;
 }
@@ -2325,7 +2325,7 @@ int yaffs_rmdir(const YCHAR *path)
 		path = alt_path;
 	result =  yaffsfs_DoUnlink(path,1);
 	if(alt_path)
-		YFREE(alt_path);
+		kfree(alt_path);
 	return result;
 }
 
@@ -2758,14 +2758,14 @@ yaffs_DIR *yaffs_opendir(const YCHAR *dirname)
 		yaffsfs_SetError(-ENOTDIR);
 	else {
 
-		dsc = YMALLOC(sizeof(yaffsfs_DirectorySearchContext));
+		dsc = kmalloc(sizeof(yaffsfs_DirectorySearchContext), 0);
 		dir = (yaffs_DIR *)dsc;
 
 		if(dsc){
 			memset(dsc,0,sizeof(yaffsfs_DirectorySearchContext));
                         dsc->magic = YAFFS_MAGIC;
                         dsc->dirObj = obj;
-                        yaffs_strncpy(dsc->name,dirname,NAME_MAX);
+                        strncpy(dsc->name,dirname,NAME_MAX);
                         INIT_LIST_HEAD(&dsc->others);
 
                         if(!search_contexts.next)
@@ -2796,10 +2796,10 @@ struct yaffs_dirent *yaffs_readdir(yaffs_DIR *dirp)
 			dsc->de.d_dont_use = (unsigned)dsc->nextReturn;
 			dsc->de.d_off = dsc->offset++;
 			yaffs_get_obj_name(dsc->nextReturn,dsc->de.d_name,NAME_MAX);
-			if(yaffs_strnlen(dsc->de.d_name,NAME_MAX+1) == 0)
+			if(strnlen(dsc->de.d_name,NAME_MAX+1) == 0)
 			{
 				/* this should not happen! */
-				yaffs_strcpy(dsc->de.d_name,_Y("zz"));
+				strcpy(dsc->de.d_name,_Y("zz"));
 			}
 			dsc->de.d_reclen = sizeof(struct yaffs_dirent);
 			retVal = &dsc->de;
@@ -2840,7 +2840,7 @@ int yaffs_closedir(yaffs_DIR *dirp)
         yaffsfs_Lock();
         dsc->magic = 0;
         list_del(&dsc->others); /* unhook from list */
-        YFREE(dsc);
+        kfree(dsc);
         yaffsfs_Unlock();
         return 0;
 }
@@ -2875,7 +2875,7 @@ int yaffs_symlink(const YCHAR *oldpath, const YCHAR *newpath)
 		yaffsfs_SetError(-ENOTDIR);
 	else if(loop)
 		yaffsfs_SetError(-ELOOP);
-	else if( !parent || yaffs_strnlen(name,5) < 1)
+	else if( !parent || strnlen(name,5) < 1)
 		yaffsfs_SetError(-ENOENT);
 	else if(parent->my_dev->read_only)
 		yaffsfs_SetError(-EROFS);
@@ -2923,7 +2923,7 @@ int yaffs_readlink(const YCHAR *path, YCHAR *buf, int bufsiz)
 	else {
 		YCHAR *alias = obj->variant.symlink_variant.alias;
 		memset(buf,0,bufsiz);
-		yaffs_strncpy(buf,alias,bufsiz - 1);
+		strncpy(buf,alias,bufsiz - 1);
 		retVal = 0;
 	}
 	yaffsfs_Unlock();
diff --git a/direct/ydirectenv.h b/direct/ydirectenv.h
index ceaa6c8..536ff22 100644
--- a/direct/ydirectenv.h
+++ b/direct/ydirectenv.h
@@ -36,13 +36,6 @@
 #define YCHAR char
 #define YUCHAR unsigned char
 #define _Y(x) x
-#define yaffs_strcat(a,b)    strcat(a,b)
-#define yaffs_strcpy(a,b)    strcpy(a,b)
-#define yaffs_strncpy(a,b,c) strncpy(a,b,c)
-#define yaffs_strncmp(a,b,c) strncmp(a,b,c)
-#define yaffs_strnlen(s,m)	     strnlen(s,m)
-#define yaffs_sprintf	     sprintf
-#define yaffs_toupper(a)     toupper(a)
 
 #define hweight8(x)	yaffs_hweight8(x)
 #define hweight32(x)	yaffs_hweight32(x)
@@ -50,7 +43,7 @@
 void yaffs_qsort(void *aa, size_t n, size_t es,
         int (*cmp)(const void *, const void *));
 
-#define yaffs_sort(base, n, sz, cmp_fn) yaffs_qsort(base, n, sz, cmp_fn)
+#define sort(base, n, sz, cmp_fn, swp) yaffs_qsort(base, n, sz, cmp_fn)
         
 #define YAFFS_PATH_DIVIDERS  "/"
 
@@ -60,14 +53,12 @@ void yaffs_qsort(void *aa, size_t n, size_t es,
 #define Y_INLINE __inline__
 #endif
 
-#define YMALLOC(x) yaffs_malloc(x)
-#define YFREE(x)   free(x)
-#define YMALLOC_ALT(x) yaffs_malloc(x)
-#define YFREE_ALT(x)   free(x)
+#define kmalloc(x,flags) yaffs_malloc(x)
+#define kfree(x)   yaffs_free(x)
+#define vmalloc(x) yaffs_malloc(x)
+#define vfree(x) yaffs_free(x)
 
-#define YMALLOC_DMA(x) yaffs_malloc(x)
-
-#define YYIELD()  do {} while(0)
+#define cond_resched()  do {} while(0)
 
 
 
@@ -93,9 +84,6 @@ void yaffs_qsort(void *aa, size_t n, size_t es,
 #define YAFFS_ROOT_MODE				0666
 #define YAFFS_LOSTNFOUND_MODE		0666
 
-#define yaffs_sum_cmp(x,y) ((x) == (y))
-#define yaffs_strcmp(a,b) strcmp(a,b)
-
 #include "yaffs_list.h"
 
 #include "yaffsfs.h"
diff --git a/direct/yportenv.h b/direct/yportenv.h
index 543c129..597898e 100644
--- a/direct/yportenv.h
+++ b/direct/yportenv.h
@@ -43,20 +43,14 @@
 #include "string.h"
 
 
-#define YMALLOC(x) malloc(x)
-#define YFREE(x)   free(x)
-#define YMALLOC_ALT(x) malloc(x)
-#define YFREE_ALT(x) free(x)
+#define kmalloc(x) malloc(x)
+#define kfree(x)   free(x)
+#define vmalloc(x) malloc(x)
+#define vfree(x) free(x)
 
 #define YCHAR char
 #define YUCHAR unsigned char
 #define _Y(x)     x
-#define yaffs_strcat(a, b)     strcat(a, b)
-#define yaffs_strcpy(a, b)     strcpy(a, b)
-#define yaffs_strncpy(a, b, c) strncpy(a, b, c)
-#define yaffs_strnlen(s,m)	       strnlen(s,m)
-#define yaffs_sprintf	       sprintf
-#define yaffs_toupper(a)       toupper(a)
 
 #define Y_INLINE inline
 
@@ -75,7 +69,7 @@
 #define YAFFS_LOSTNFOUND_MODE		0700
 
 #define yaffs_sum_cmp(x, y) ((x) == (y))
-#define yaffs_strcmp(a, b) strcmp(a, b)
+#define strcmp(a, b) strcmp(a, b)
 
 #else
 /* Should have specified a configuration type */
diff --git a/patches/yaffs_linux_allocator.c b/patches/yaffs_linux_allocator.c
index b538776..395f4ea 100644
--- a/patches/yaffs_linux_allocator.c
+++ b/patches/yaffs_linux_allocator.c
@@ -67,7 +67,7 @@ void yaffs_deinit_raw_tnodes_and_objs(struct yaffs_dev *dev)
 			YBUG();
 		}
 
-		YFREE(allocator);
+		kfree(allocator);
 
 	} else {
 		T(YAFFS_TRACE_ALWAYS,
@@ -114,7 +114,7 @@ void yaffs_init_raw_tnodes_and_objs(struct yaffs_dev *dev)
 	else if(mount_id >= 10){
 		T(YAFFS_TRACE_ALWAYS,(TSTR("Bad mount_id %u\n"),mount_id));
 	} else {
-		 allocator = YMALLOC(sizeof(yaffs_Allocator));
+		 allocator = kmalloc(sizeof(yaffs_Allocator));
 		 memset(allocator,0,sizeof(yaffs_Allocator));
 		 dev->allocator = allocator;
 
diff --git a/yaffs_allocator.c b/yaffs_allocator.c
index b9fe31e..9af15c7 100644
--- a/yaffs_allocator.c
+++ b/yaffs_allocator.c
@@ -16,7 +16,7 @@
 #include "yaffs_trace.h"
 #include "yportenv.h"
 
-#ifdef CONFIG_YAFFS_YMALLOC_ALLOCATOR
+#ifdef CONFIG_YAFFS_KMALLOC_ALLOCATOR
 
 void yaffs_deinit_raw_tnodes_and_objs(struct yaffs_dev *dev)
 {
@@ -30,13 +30,13 @@ void yaffs_init_raw_tnodes_and_objs(struct yaffs_dev *dev)
 
 struct yaffs_tnode *yaffs_alloc_raw_tnode(struct yaffs_dev *dev)
 {
-	return (struct yaffs_tnode *)YMALLOC(dev->tnode_size);
+	return (struct yaffs_tnode *)kmalloc(dev->tnode_size, GFP_NOFS);
 }
 
 void yaffs_free_raw_tnode(struct yaffs_dev *dev, struct yaffs_tnode *tn)
 {
 	dev = dev;
-	YFREE(tn);
+	kfree(tn);
 }
 
 void yaffs_init_raw_objs(struct yaffs_dev *dev)
@@ -52,14 +52,14 @@ void yaffs_deinit_raw_objs(struct yaffs_dev *dev)
 struct yaffs_obj *yaffs_alloc_raw_obj(struct yaffs_dev *dev)
 {
 	dev = dev;
-	return (struct yaffs_obj *)YMALLOC(sizeof(struct yaffs_obj));
+	return (struct yaffs_obj *)kmalloc(sizeof(struct yaffs_obj));
 }
 
 void yaffs_free_raw_obj(struct yaffs_dev *dev, struct yaffs_obj *obj)
 {
 
 	dev = dev;
-	YFREE(obj);
+	kfree(obj);
 }
 
 #else
@@ -103,8 +103,8 @@ static void yaffs_deinit_raw_tnodes(struct yaffs_dev *dev)
 	while (allocator->alloc_tnode_list) {
 		tmp = allocator->alloc_tnode_list->next;
 
-		YFREE(allocator->alloc_tnode_list->tnodes);
-		YFREE(allocator->alloc_tnode_list);
+		kfree(allocator->alloc_tnode_list->tnodes);
+		kfree(allocator->alloc_tnode_list);
 		allocator->alloc_tnode_list = tmp;
 
 	}
@@ -149,7 +149,7 @@ static int yaffs_create_tnodes(struct yaffs_dev *dev, int n_tnodes)
 
 	/* make these things */
 
-	new_tnodes = YMALLOC(n_tnodes * dev->tnode_size);
+	new_tnodes = kmalloc(n_tnodes * dev->tnode_size, GFP_NOFS);
 	mem = (u8 *) new_tnodes;
 
 	if (!new_tnodes) {
@@ -177,7 +177,7 @@ static int yaffs_create_tnodes(struct yaffs_dev *dev, int n_tnodes)
 	 * but it just means we can't free this bunch of tnodes later.
 	 */
 
-	tnl = YMALLOC(sizeof(struct yaffs_tnode_list));
+	tnl = kmalloc(sizeof(struct yaffs_tnode_list), GFP_NOFS);
 	if (!tnl) {
 		T(YAFFS_TRACE_ERROR,
 		  (TSTR
@@ -261,8 +261,8 @@ static void yaffs_deinit_raw_objs(struct yaffs_dev *dev)
 
 	while (allocator->allocated_obj_list) {
 		tmp = allocator->allocated_obj_list->next;
-		YFREE(allocator->allocated_obj_list->objects);
-		YFREE(allocator->allocated_obj_list);
+		kfree(allocator->allocated_obj_list->objects);
+		kfree(allocator->allocated_obj_list);
 
 		allocator->allocated_obj_list = tmp;
 	}
@@ -289,16 +289,16 @@ static int yaffs_create_free_objs(struct yaffs_dev *dev, int n_obj)
 		return YAFFS_OK;
 
 	/* make these things */
-	new_objs = YMALLOC(n_obj * sizeof(struct yaffs_obj));
-	list = YMALLOC(sizeof(struct yaffs_obj_list));
+	new_objs = kmalloc(n_obj * sizeof(struct yaffs_obj), GFP_NOFS);
+	list = kmalloc(sizeof(struct yaffs_obj_list), GFP_NOFS);
 
 	if (!new_objs || !list) {
 		if (new_objs) {
-			YFREE(new_objs);
+			kfree(new_objs);
 			new_objs = NULL;
 		}
 		if (list) {
-			YFREE(list);
+			kfree(list);
 			list = NULL;
 		}
 		T(YAFFS_TRACE_ALLOCATE,
@@ -371,7 +371,7 @@ void yaffs_deinit_raw_tnodes_and_objs(struct yaffs_dev *dev)
 		yaffs_deinit_raw_tnodes(dev);
 		yaffs_deinit_raw_objs(dev);
 
-		YFREE(dev->allocator);
+		kfree(dev->allocator);
 		dev->allocator = NULL;
 	} else {
 		YBUG();
@@ -383,7 +383,7 @@ void yaffs_init_raw_tnodes_and_objs(struct yaffs_dev *dev)
 	struct yaffs_allocator *allocator;
 
 	if (!dev->allocator) {
-		allocator = YMALLOC(sizeof(struct yaffs_allocator));
+		allocator = kmalloc(sizeof(struct yaffs_allocator), GFP_NOFS);
 		if (allocator) {
 			dev->allocator = allocator;
 			yaffs_init_raw_tnodes(dev);
diff --git a/yaffs_attribs.c b/yaffs_attribs.c
index 241c08a..9b47d37 100644
--- a/yaffs_attribs.c
+++ b/yaffs_attribs.c
@@ -64,7 +64,7 @@ loff_t yaffs_get_file_size(struct yaffs_obj *obj)
 		alias = obj->variant.symlink_variant.alias;
 		if (!alias)
 			return 0;
-		return yaffs_strnlen(alias, YAFFS_MAX_ALIAS_LENGTH);
+		return strnlen(alias, YAFFS_MAX_ALIAS_LENGTH);
 	default:
 		return 0;
 	}
diff --git a/yaffs_checkptrw.c b/yaffs_checkptrw.c
index 02b8ce6..66ce541 100644
--- a/yaffs_checkptrw.c
+++ b/yaffs_checkptrw.c
@@ -154,7 +154,7 @@ int yaffs2_checkpt_open(struct yaffs_dev *dev, int writing)
 
 	if (!dev->checkpt_buffer)
 		dev->checkpt_buffer =
-		    YMALLOC_DMA(dev->param.total_bytes_per_chunk);
+		    kmalloc(dev->param.total_bytes_per_chunk, GFP_NOFS);
 	if (!dev->checkpt_buffer)
 		return 0;
 
@@ -182,7 +182,7 @@ int yaffs2_checkpt_open(struct yaffs_dev *dev, int writing)
 		    (dev->internal_end_block - dev->internal_start_block) / 16 +
 		    2;
 		dev->checkpt_block_list =
-		    YMALLOC(sizeof(int) * dev->checkpt_max_blocks);
+		    kmalloc(sizeof(int) * dev->checkpt_max_blocks, GFP_NOFS);
 		if (!dev->checkpt_block_list)
 			return 0;
 
@@ -387,7 +387,7 @@ int yaffs_checkpt_close(struct yaffs_dev *dev)
 				/* Todo this looks odd... */
 			}
 		}
-		YFREE(dev->checkpt_block_list);
+		kfree(dev->checkpt_block_list);
 		dev->checkpt_block_list = NULL;
 	}
 
@@ -400,7 +400,7 @@ int yaffs_checkpt_close(struct yaffs_dev *dev)
 
 	if (dev->checkpt_buffer) {
 		/* free the buffer */
-		YFREE(dev->checkpt_buffer);
+		kfree(dev->checkpt_buffer);
 		dev->checkpt_buffer = NULL;
 		return 1;
 	} else {
diff --git a/yaffs_guts.c b/yaffs_guts.c
index c56e060..15d0238 100644
--- a/yaffs_guts.c
+++ b/yaffs_guts.c
@@ -41,62 +41,13 @@
 
 #include "yaffs_ecc.h"
 
-/* Robustification (if it ever comes about...) */
-static void yaffs_retire_block(struct yaffs_dev *dev, int flash_block);
-static void yaffs_handle_chunk_wr_error(struct yaffs_dev *dev, int nand_chunk,
-					int erased_ok);
-static void yaffs_handle_chunk_wr_ok(struct yaffs_dev *dev, int nand_chunk,
-				     const u8 * data,
-				     const struct yaffs_ext_tags *tags);
-static void yaffs_handle_chunk_update(struct yaffs_dev *dev, int nand_chunk,
-				      const struct yaffs_ext_tags *tags);
-
-/* Other local prototypes */
-static void yaffs_update_parent(struct yaffs_obj *obj);
-static int yaffs_unlink_obj(struct yaffs_obj *obj);
-static int yaffs_obj_cache_dirty(struct yaffs_obj *obj);
-
-static int yaffs_write_new_chunk(struct yaffs_dev *dev,
-				 const u8 * buffer,
-				 struct yaffs_ext_tags *tags, int use_reserver);
-
-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,
-				   struct yaffs_xattr_mod *xmod);
+/* Forward declarations */
 
-static void yaffs_remove_obj_from_dir(struct yaffs_obj *obj);
-static int yaffs_generic_obj_del(struct yaffs_obj *in);
 
-static int yaffs_check_chunk_erased(struct yaffs_dev *dev, int nand_chunk);
-
-static int yaffs_unlink_worker(struct yaffs_obj *obj);
-
-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,
-			     struct yaffs_block_info **block_ptr);
-
-static void yaffs_check_obj_details_loaded(struct yaffs_obj *in);
-
-static void yaffs_invalidate_whole_cache(struct yaffs_obj *in);
-static void yaffs_invalidate_chunk_cache(struct yaffs_obj *object,
-					 int chunk_id);
-
-static int yaffs_find_chunk_in_file(struct yaffs_obj *in, int inode_chunk,
-				    struct yaffs_ext_tags *tags);
+static int yaffs_wr_data_obj(struct yaffs_obj *in, int inode_chunk,
+			     const u8 * buffer, int n_bytes, int use_reserve);
 
-static int yaffs_verify_chunk_written(struct yaffs_dev *dev,
-				      int nand_chunk,
-				      const u8 * data,
-				      struct yaffs_ext_tags *tags);
 
-static void yaffs_load_name_from_oh(struct yaffs_dev *dev, YCHAR * name,
-				    const YCHAR * oh_name, int buff_size);
-static void yaffs_load_oh_from_name(struct yaffs_dev *dev, YCHAR * oh_name,
-				    const YCHAR * name);
 
 /* Function to calculate chunk and offset */
 
@@ -186,7 +137,7 @@ static int yaffs_init_tmp_buffers(struct yaffs_dev *dev)
 	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 =
-		    YMALLOC_DMA(dev->param.total_bytes_per_chunk);
+		    kmalloc(dev->param.total_bytes_per_chunk, GFP_NOFS);
 	}
 
 	return buf ? YAFFS_OK : YAFFS_FAIL;
@@ -229,7 +180,7 @@ u8 *yaffs_get_temp_buffer(struct yaffs_dev * dev, int line_no)
 	 */
 
 	dev->unmanaged_buffer_allocs++;
-	return YMALLOC(dev->data_bytes_per_chunk);
+	return kmalloc(dev->data_bytes_per_chunk, GFP_NOFS);
 
 }
 
@@ -251,7 +202,7 @@ void yaffs_release_temp_buffer(struct yaffs_dev *dev, u8 * buffer, int line_no)
 		T(YAFFS_TRACE_BUFFERS,
 		  (TSTR("Releasing unmanaged temp buffer in line %d" TENDSTR),
 		   line_no));
-		YFREE(buffer);
+		kfree(buffer);
 		dev->unmanaged_buffer_deallocs++;
 	}
 
@@ -283,6 +234,66 @@ int yaffs_is_managed_tmp_buffer(struct yaffs_dev *dev, const u8 * buffer)
 }
 
 /*
+ * Functions for robustisizing TODO
+ *
+ */
+
+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;
+}
+
+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 yaffs_handle_chunk_error(struct yaffs_dev *dev,
+			      struct yaffs_block_info *bi)
+{
+	if (!bi->gc_prioritise) {
+		bi->gc_prioritise = 1;
+		dev->has_pending_prioritised_gc = 1;
+		bi->chunk_error_strikes++;
+
+		if (bi->chunk_error_strikes > 3) {
+			bi->needs_retiring = 1;	/* Too many stikes, so retire this */
+			T(YAFFS_TRACE_ALWAYS,
+			  (TSTR("yaffs: Block struck out" TENDSTR)));
+
+		}
+	}
+}
+
+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;
+	struct yaffs_block_info *bi = yaffs_get_block_info(dev, flash_block);
+
+	yaffs_handle_chunk_error(dev, bi);
+
+	if (erased_ok) {
+		/* Was an actual write failure, so mark the block for retirement  */
+		bi->needs_retiring = 1;
+		T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS,
+		  (TSTR("**>> Block %d needs retiring" TENDSTR), flash_block));
+	}
+
+	/* Delete the chunk */
+	yaffs_chunk_del(dev, nand_chunk, 1, __LINE__);
+	yaffs_skip_rest_of_block(dev);
+}
+
+/*
  * Verification code
  */
 
@@ -372,6 +383,150 @@ static int yaffs_verify_chunk_written(struct yaffs_dev *dev,
 	return retval;
 }
 
+
+int yaffs_check_alloc_available(struct yaffs_dev *dev, int n_chunks)
+{
+	int reserved_chunks;
+	int reserved_blocks = dev->param.n_reserved_blocks;
+	int checkpt_blocks;
+
+	checkpt_blocks = yaffs_calc_checkpt_blocks_required(dev);
+
+	reserved_chunks =
+	    ((reserved_blocks + checkpt_blocks) * dev->param.chunks_per_block);
+
+	return (dev->n_free_chunks > (reserved_chunks + n_chunks));
+}
+
+static int yaffs_find_alloc_block(struct yaffs_dev *dev)
+{
+	int i;
+
+	struct yaffs_block_info *bi;
+
+	if (dev->n_erased_blocks < 1) {
+		/* Hoosterman we've got a problem.
+		 * Can't get space to gc
+		 */
+		T(YAFFS_TRACE_ERROR,
+		  (TSTR("yaffs tragedy: no more erased blocks" TENDSTR)));
+
+		return -1;
+	}
+
+	/* Find an empty block. */
+
+	for (i = dev->internal_start_block; i <= dev->internal_end_block; i++) {
+		dev->alloc_block_finder++;
+		if (dev->alloc_block_finder < dev->internal_start_block
+		    || dev->alloc_block_finder > dev->internal_end_block) {
+			dev->alloc_block_finder = dev->internal_start_block;
+		}
+
+		bi = yaffs_get_block_info(dev, dev->alloc_block_finder);
+
+		if (bi->block_state == YAFFS_BLOCK_STATE_EMPTY) {
+			bi->block_state = YAFFS_BLOCK_STATE_ALLOCATING;
+			dev->seq_number++;
+			bi->seq_number = dev->seq_number;
+			dev->n_erased_blocks--;
+			T(YAFFS_TRACE_ALLOCATE,
+			  (TSTR("Allocated block %d, seq  %d, %d left" TENDSTR),
+			   dev->alloc_block_finder, dev->seq_number,
+			   dev->n_erased_blocks));
+			return dev->alloc_block_finder;
+		}
+	}
+
+	T(YAFFS_TRACE_ALWAYS,
+	  (TSTR
+	   ("yaffs tragedy: no more erased blocks, but there should have been %d"
+	    TENDSTR), dev->n_erased_blocks));
+
+	return -1;
+}
+static int yaffs_alloc_chunk(struct yaffs_dev *dev, int use_reserver,
+			     struct yaffs_block_info **block_ptr)
+{
+	int ret_val;
+	struct yaffs_block_info *bi;
+
+	if (dev->alloc_block < 0) {
+		/* Get next block to allocate off */
+		dev->alloc_block = yaffs_find_alloc_block(dev);
+		dev->alloc_page = 0;
+	}
+
+	if (!use_reserver && !yaffs_check_alloc_available(dev, 1)) {
+		/* Not enough space to allocate unless we're allowed to use the reserve. */
+		return -1;
+	}
+
+	if (dev->n_erased_blocks < dev->param.n_reserved_blocks
+	    && dev->alloc_page == 0) {
+		T(YAFFS_TRACE_ALLOCATE, (TSTR("Allocating reserve" TENDSTR)));
+	}
+
+	/* Next page please.... */
+	if (dev->alloc_block >= 0) {
+		bi = yaffs_get_block_info(dev, dev->alloc_block);
+
+		ret_val = (dev->alloc_block * dev->param.chunks_per_block) +
+		    dev->alloc_page;
+		bi->pages_in_use++;
+		yaffs_set_chunk_bit(dev, dev->alloc_block, dev->alloc_page);
+
+		dev->alloc_page++;
+
+		dev->n_free_chunks--;
+
+		/* If the block is full set the state to full */
+		if (dev->alloc_page >= dev->param.chunks_per_block) {
+			bi->block_state = YAFFS_BLOCK_STATE_FULL;
+			dev->alloc_block = -1;
+		}
+
+		if (block_ptr)
+			*block_ptr = bi;
+
+		return ret_val;
+	}
+
+	T(YAFFS_TRACE_ERROR,
+	  (TSTR("!!!!!!!!! Allocator out !!!!!!!!!!!!!!!!!" TENDSTR)));
+
+	return -1;
+}
+
+static int yaffs_get_erased_chunks(struct yaffs_dev *dev)
+{
+	int n;
+
+	n = dev->n_erased_blocks * dev->param.chunks_per_block;
+
+	if (dev->alloc_block > 0)
+		n += (dev->param.chunks_per_block - dev->alloc_page);
+
+	return n;
+
+}
+
+/*
+ * yaffs_skip_rest_of_block() skips over the rest of the allocation block
+ * if we don't want to write to it.
+ */
+void yaffs_skip_rest_of_block(struct yaffs_dev *dev)
+{
+	if (dev->alloc_block > 0) {
+		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;
+		}
+	}
+}
+
 static int yaffs_write_new_chunk(struct yaffs_dev *dev,
 				 const u8 * data,
 				 struct yaffs_ext_tags *tags, int use_reserver)
@@ -522,66 +677,6 @@ static void yaffs_retire_block(struct yaffs_dev *dev, int flash_block)
 	dev->n_retired_blocks++;
 }
 
-/*
- * Functions for robustisizing TODO
- *
- */
-
-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;
-}
-
-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 yaffs_handle_chunk_error(struct yaffs_dev *dev,
-			      struct yaffs_block_info *bi)
-{
-	if (!bi->gc_prioritise) {
-		bi->gc_prioritise = 1;
-		dev->has_pending_prioritised_gc = 1;
-		bi->chunk_error_strikes++;
-
-		if (bi->chunk_error_strikes > 3) {
-			bi->needs_retiring = 1;	/* Too many stikes, so retire this */
-			T(YAFFS_TRACE_ALWAYS,
-			  (TSTR("yaffs: Block struck out" TENDSTR)));
-
-		}
-	}
-}
-
-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;
-	struct yaffs_block_info *bi = yaffs_get_block_info(dev, flash_block);
-
-	yaffs_handle_chunk_error(dev, bi);
-
-	if (erased_ok) {
-		/* Was an actual write failure, so mark the block for retirement  */
-		bi->needs_retiring = 1;
-		T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS,
-		  (TSTR("**>> Block %d needs retiring" TENDSTR), flash_block));
-	}
-
-	/* Delete the chunk */
-	yaffs_chunk_del(dev, nand_chunk, 1, __LINE__);
-	yaffs_skip_rest_of_block(dev);
-}
-
 /*---------------- Name handling functions ------------*/
 
 static u16 yaffs_calc_name_sum(const YCHAR * name)
@@ -607,9 +702,9 @@ 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 && 
-	        yaffs_strnlen(name, YAFFS_SHORT_NAME_LENGTH + 1) <=
+	        strnlen(name, YAFFS_SHORT_NAME_LENGTH + 1) <=
 	    YAFFS_SHORT_NAME_LENGTH)
-		yaffs_strcpy(obj->short_name, name);
+		strcpy(obj->short_name, name);
 	else
 		obj->short_name[0] = _Y('\0');
 #endif
@@ -884,6 +979,14 @@ struct yaffs_tnode *yaffs_add_find_tnode_0(struct yaffs_dev *dev,
 	return tn;
 }
 
+static int yaffs_tags_match(const struct yaffs_ext_tags *tags, int obj_id,
+			    int chunk_obj)
+{
+	return (tags->chunk_id == chunk_obj &&
+		tags->obj_id == obj_id && !tags->is_deleted) ? 1 : 0;
+
+}
+
 static int yaffs_find_chunk_in_group(struct yaffs_dev *dev, int the_chunk,
 				     struct yaffs_ext_tags *tags, int obj_id,
 				     int inode_chunk)
@@ -911,6 +1014,194 @@ 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,
+				    struct yaffs_ext_tags *tags)
+{
+	/*Get the Tnode, then get the level 0 offset chunk offset */
+	struct yaffs_tnode *tn;
+	int the_chunk = -1;
+	struct yaffs_ext_tags local_tags;
+	int ret_val = -1;
+
+	struct yaffs_dev *dev = in->my_dev;
+
+	if (!tags) {
+		/* Passed a NULL, so use our own tags space */
+		tags = &local_tags;
+	}
+
+	tn = yaffs_find_tnode_0(dev, &in->variant.file_variant, inode_chunk);
+
+	if (tn) {
+		the_chunk = yaffs_get_group_base(dev, tn, inode_chunk);
+
+		ret_val =
+		    yaffs_find_chunk_in_group(dev, the_chunk, tags, in->obj_id,
+					      inode_chunk);
+	}
+	return ret_val;
+}
+
+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 */
+	struct yaffs_tnode *tn;
+	int the_chunk = -1;
+	struct yaffs_ext_tags local_tags;
+
+	struct yaffs_dev *dev = in->my_dev;
+	int ret_val = -1;
+
+	if (!tags) {
+		/* Passed a NULL, so use our own tags space */
+		tags = &local_tags;
+	}
+
+	tn = yaffs_find_tnode_0(dev, &in->variant.file_variant, inode_chunk);
+
+	if (tn) {
+
+		the_chunk = yaffs_get_group_base(dev, tn, inode_chunk);
+
+		ret_val =
+		    yaffs_find_chunk_in_group(dev, the_chunk, tags, in->obj_id,
+					      inode_chunk);
+
+		/* Delete the entry in the filestructure (if found) */
+		if (ret_val != -1)
+			yaffs_load_tnode_0(dev, tn, inode_chunk, 0);
+	}
+
+	return ret_val;
+}
+
+int yaffs_put_chunk_in_file(struct yaffs_obj *in, int inode_chunk,
+			    int nand_chunk, int in_scan)
+{
+	/* NB in_scan is zero unless scanning.
+	 * For forward scanning, in_scan is > 0;
+	 * for backward scanning in_scan is < 0
+	 *
+	 * nand_chunk = 0 is a dummy insert to make sure the tnodes are there.
+	 */
+
+	struct yaffs_tnode *tn;
+	struct yaffs_dev *dev = in->my_dev;
+	int existing_cunk;
+	struct yaffs_ext_tags existing_tags;
+	struct yaffs_ext_tags new_tags;
+	unsigned existing_serial, new_serial;
+
+	if (in->variant_type != YAFFS_OBJECT_TYPE_FILE) {
+		/* Just ignore an attempt at putting a chunk into a non-file during scanning
+		 * If it is not during Scanning then something went wrong!
+		 */
+		if (!in_scan) {
+			T(YAFFS_TRACE_ERROR,
+			  (TSTR
+			   ("yaffs tragedy:attempt to put data chunk into a non-file"
+			    TENDSTR)));
+			YBUG();
+		}
+
+		yaffs_chunk_del(dev, nand_chunk, 1, __LINE__);
+		return YAFFS_OK;
+	}
+
+	tn = yaffs_add_find_tnode_0(dev,
+				    &in->variant.file_variant,
+				    inode_chunk, NULL);
+	if (!tn)
+		return YAFFS_FAIL;
+
+	if (!nand_chunk)
+		/* Dummy insert, bail now */
+		return YAFFS_OK;
+
+	existing_cunk = yaffs_get_group_base(dev, tn, inode_chunk);
+
+	if (in_scan != 0) {
+		/* If we're scanning then we need to test for duplicates
+		 * NB This does not need to be efficient since it should only ever
+		 * happen when the power fails during a write, then only one
+		 * chunk should ever be affected.
+		 *
+		 * Correction for YAFFS2: This could happen quite a lot and we need to think about efficiency! TODO
+		 * Update: For backward scanning we don't need to re-read tags so this is quite cheap.
+		 */
+
+		if (existing_cunk > 0) {
+			/* NB Right now existing chunk will not be real chunk_id if the chunk group size > 1
+			 *    thus we have to do a FindChunkInFile to get the real chunk id.
+			 *
+			 * We have a duplicate now we need to decide which one to use:
+			 *
+			 * Backwards scanning YAFFS2: The old one is what we use, dump the new one.
+			 * Forward scanning YAFFS2: The new one is what we use, dump the old one.
+			 * YAFFS1: Get both sets of tags and compare serial numbers.
+			 */
+
+			if (in_scan > 0) {
+				/* Only do this for forward scanning */
+				yaffs_rd_chunk_tags_nand(dev,
+							 nand_chunk,
+							 NULL, &new_tags);
+
+				/* Do a proper find */
+				existing_cunk =
+				    yaffs_find_chunk_in_file(in, inode_chunk,
+							     &existing_tags);
+			}
+
+			if (existing_cunk <= 0) {
+				/*Hoosterman - how did this happen? */
+
+				T(YAFFS_TRACE_ERROR,
+				  (TSTR
+				   ("yaffs tragedy: existing chunk < 0 in scan"
+				    TENDSTR)));
+
+			}
+
+			/* NB The deleted flags should be false, otherwise the chunks will
+			 * not be loaded during a scan
+			 */
+
+			if (in_scan > 0) {
+				new_serial = new_tags.serial_number;
+				existing_serial = existing_tags.serial_number;
+			}
+
+			if ((in_scan > 0) &&
+			    (existing_cunk <= 0 ||
+			     ((existing_serial + 1) & 3) == new_serial)) {
+				/* Forward scanning.
+				 * Use new
+				 * Delete the old one and drop through to update the tnode
+				 */
+				yaffs_chunk_del(dev, existing_cunk, 1,
+						__LINE__);
+			} else {
+				/* Backward scanning or we want to use the existing one
+				 * Use existing.
+				 * Delete the new one and return early so that the tnode isn't changed
+				 */
+				yaffs_chunk_del(dev, nand_chunk, 1, __LINE__);
+				return YAFFS_OK;
+			}
+		}
+
+	}
+
+	if (existing_cunk == 0)
+		in->n_data_chunks++;
+
+	yaffs_load_tnode_0(dev, tn, inode_chunk, nand_chunk);
+
+	return YAFFS_OK;
+}
+
 static void yaffs_soft_del_chunk(struct yaffs_dev *dev, int chunk)
 {
 	struct yaffs_block_info *the_block;
@@ -991,6 +1282,452 @@ static int yaffs_soft_del_worker(struct yaffs_obj *in, struct yaffs_tnode *tn,
 
 }
 
+static void yaffs_remove_obj_from_dir(struct yaffs_obj *obj)
+{
+	struct yaffs_dev *dev = obj->my_dev;
+	struct yaffs_obj *parent;
+
+	yaffs_verify_obj_in_dir(obj);
+	parent = obj->parent;
+
+	yaffs_verify_dir(parent);
+
+	if (dev && dev->param.remove_obj_fn)
+		dev->param.remove_obj_fn(obj);
+
+	list_del_init(&obj->siblings);
+	obj->parent = NULL;
+
+	yaffs_verify_dir(parent);
+}
+
+void yaffs_add_obj_to_dir(struct yaffs_obj *directory, struct yaffs_obj *obj)
+{
+	if (!directory) {
+		T(YAFFS_TRACE_ALWAYS,
+		  (TSTR
+		   ("tragedy: Trying to add an object to a null pointer directory"
+		    TENDSTR)));
+		YBUG();
+		return;
+	}
+	if (directory->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) {
+		T(YAFFS_TRACE_ALWAYS,
+		  (TSTR
+		   ("tragedy: Trying to add an object to a non-directory"
+		    TENDSTR)));
+		YBUG();
+	}
+
+	if (obj->siblings.prev == NULL) {
+		/* Not initialised */
+		YBUG();
+	}
+
+	yaffs_verify_dir(directory);
+
+	yaffs_remove_obj_from_dir(obj);
+
+	/* Now add it */
+	list_add(&obj->siblings, &directory->variant.dir_variant.children);
+	obj->parent = directory;
+
+	if (directory == obj->my_dev->unlinked_dir
+	    || directory == obj->my_dev->del_dir) {
+		obj->unlinked = 1;
+		obj->my_dev->n_unlinked_files++;
+		obj->rename_allowed = 0;
+	}
+
+	yaffs_verify_dir(directory);
+	yaffs_verify_obj_in_dir(obj);
+}
+
+static int yaffs_change_obj_name(struct yaffs_obj *obj,
+				 struct yaffs_obj *new_dir,
+				 const YCHAR * new_name, int force, int shadows)
+{
+	int unlink_op;
+	int del_op;
+
+	struct yaffs_obj *existing_target;
+
+	if (new_dir == NULL)
+		new_dir = obj->parent;	/* use the old directory */
+
+	if (new_dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) {
+		T(YAFFS_TRACE_ALWAYS,
+		  (TSTR
+		   ("tragedy: yaffs_change_obj_name: new_dir is not a directory"
+		    TENDSTR)));
+		YBUG();
+	}
+
+	/* TODO: Do we need this different handling for YAFFS2 and YAFFS1?? */
+	if (obj->my_dev->param.is_yaffs2)
+		unlink_op = (new_dir == obj->my_dev->unlinked_dir);
+	else
+		unlink_op = (new_dir == obj->my_dev->unlinked_dir
+			     && obj->variant_type == YAFFS_OBJECT_TYPE_FILE);
+
+	del_op = (new_dir == obj->my_dev->del_dir);
+
+	existing_target = yaffs_find_by_name(new_dir, new_name);
+
+	/* If the object is a file going into the unlinked directory,
+	 *   then it is OK to just stuff it in since duplicate names are allowed.
+	 *   else only proceed if the new name does not exist and if we're putting
+	 *   it into a directory.
+	 */
+	if ((unlink_op ||
+	     del_op ||
+	     force ||
+	     (shadows > 0) ||
+	     !existing_target) &&
+	    new_dir->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) {
+		yaffs_set_obj_name(obj, new_name);
+		obj->dirty = 1;
+
+		yaffs_add_obj_to_dir(new_dir, obj);
+
+		if (unlink_op)
+			obj->unlinked = 1;
+
+		/* If it is a deletion then we mark it as a shrink for gc purposes. */
+		if (yaffs_update_oh(obj, new_name, 0, del_op, shadows, NULL) >=
+		    0)
+			return YAFFS_OK;
+	}
+
+	return YAFFS_FAIL;
+}
+
+/*------------------------ Short Operations Cache ----------------------------------------
+ *   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 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.
+ */
+
+static int yaffs_obj_cache_dirty(struct yaffs_obj *obj)
+{
+	struct yaffs_dev *dev = obj->my_dev;
+	int i;
+	struct yaffs_cache *cache;
+	int n_caches = obj->my_dev->param.n_caches;
+
+	for (i = 0; i < n_caches; i++) {
+		cache = &dev->cache[i];
+		if (cache->object == obj && cache->dirty)
+			return 1;
+	}
+
+	return 0;
+}
+
+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;
+	struct yaffs_cache *cache;
+	int chunk_written = 0;
+	int n_caches = obj->my_dev->param.n_caches;
+
+	if (n_caches > 0) {
+		do {
+			cache = NULL;
+
+			/* Find the dirty cache for this object with the lowest chunk id. */
+			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. */
+			T(YAFFS_TRACE_ERROR,
+			  (TSTR
+			   ("yaffs tragedy: no space during cache write"
+			    TENDSTR)));
+
+		}
+	}
+
+}
+
+/*yaffs_flush_whole_cache(dev)
+ *
+ *
+ */
+
+void yaffs_flush_whole_cache(struct yaffs_dev *dev)
+{
+	struct yaffs_obj *obj;
+	int n_caches = dev->param.n_caches;
+	int i;
+
+	/* Find a dirty object in the cache and flush it...
+	 * until there are no further dirty objects.
+	 */
+	do {
+		obj = NULL;
+		for (i = 0; i < n_caches && !obj; i++) {
+			if (dev->cache[i].object && dev->cache[i].dirty)
+				obj = dev->cache[i].object;
+
+		}
+		if (obj)
+			yaffs_flush_file_cache(obj);
+
+	} while (obj);
+
+}
+
+/* Grab us a 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.
+ */
+static struct yaffs_cache *yaffs_grab_chunk_worker(struct yaffs_dev *dev)
+{
+	int i;
+
+	if (dev->param.n_caches > 0) {
+		for (i = 0; i < dev->param.n_caches; i++) {
+			if (!dev->cache[i].object)
+				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 > 0) {
+		/* Try find a non-dirty one... */
+
+		cache = yaffs_grab_chunk_worker(dev);
+
+		if (!cache) {
+			/* They were all dirty, find the last recently used object and flush
+			 * its cache, then  find again.
+			 * NB what's here is not very accurate, we actually flush the object
+			 * the last recently used page.
+			 */
+
+			/* With locking we can't assume we can use entry zero */
+
+			the_obj = NULL;
+			usage = -1;
+			cache = NULL;
+			pushout = -1;
+
+			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);
+			}
+
+		}
+		return cache;
+	} else {
+		return NULL;
+        }
+}
+
+/* Find a cached chunk */
+static struct yaffs_cache *yaffs_find_chunk_cache(const struct yaffs_obj *obj,
+						  int chunk_id)
+{
+	struct yaffs_dev *dev = obj->my_dev;
+	int i;
+	if (dev->param.n_caches > 0) {
+		for (i = 0; i < dev->param.n_caches; i++) {
+			if (dev->cache[i].object == obj &&
+			    dev->cache[i].chunk_id == chunk_id) {
+				dev->cache_hits++;
+
+				return &dev->cache[i];
+			}
+		}
+	}
+	return NULL;
+}
+
+/* Mark the chunk for the least recently used algorithym */
+static void yaffs_use_cache(struct yaffs_dev *dev, struct yaffs_cache *cache,
+			    int is_write)
+{
+
+	if (dev->param.n_caches > 0) {
+		if (dev->cache_last_use < 0 || dev->cache_last_use > 100000000) {
+			/* Reset the cache usages */
+			int i;
+			for (i = 1; i < dev->param.n_caches; i++)
+				dev->cache[i].last_use = 0;
+
+			dev->cache_last_use = 0;
+		}
+
+		dev->cache_last_use++;
+
+		cache->last_use = dev->cache_last_use;
+
+		if (is_write)
+			cache->dirty = 1;
+	}
+}
+
+/* Invalidate a single cache page.
+ * Do this when a whole page gets written,
+ * ie the short cache for this page is no longer valid.
+ */
+static void yaffs_invalidate_chunk_cache(struct yaffs_obj *object, int chunk_id)
+{
+	if (object->my_dev->param.n_caches > 0) {
+		struct yaffs_cache *cache =
+		    yaffs_find_chunk_cache(object, chunk_id);
+
+		if (cache)
+			cache->object = NULL;
+	}
+}
+
+/* Invalidate all the cache pages associated with this object
+ * Do this whenever ther file is deleted or resized.
+ */
+static void yaffs_invalidate_whole_cache(struct yaffs_obj *in)
+{
+	int i;
+	struct yaffs_dev *dev = in->my_dev;
+
+	if (dev->param.n_caches > 0) {
+		/* Invalidate it. */
+		for (i = 0; i < dev->param.n_caches; i++) {
+			if (dev->cache[i].object == in)
+				dev->cache[i].object = NULL;
+		}
+	}
+}
+
+static void yaffs_unhash_obj(struct yaffs_obj *obj)
+{
+	int bucket;
+	struct yaffs_dev *dev = obj->my_dev;
+
+	/* If it is still linked into the bucket list, free from the list */
+	if (!list_empty(&obj->hash_link)) {
+		list_del_init(&obj->hash_link);
+		bucket = yaffs_hash_fn(obj->obj_id);
+		dev->obj_bucket[bucket].count--;
+	}
+}
+
+/*  FreeObject frees up a Object and puts it back on the free list */
+static void yaffs_free_obj(struct yaffs_obj *obj)
+{
+	struct yaffs_dev *dev = obj->my_dev;
+
+	T(YAFFS_TRACE_OS,
+	  (TSTR("FreeObject %p inode %p" TENDSTR), obj, obj->my_inode));
+
+	if (!obj)
+		YBUG();
+	if (obj->parent)
+		YBUG();
+	if (!list_empty(&obj->siblings))
+		YBUG();
+
+	if (obj->my_inode) {
+		/* We're still hooked up to a cached inode.
+		 * Don't delete now, but mark for later deletion
+		 */
+		obj->defered_free = 1;
+		return;
+	}
+
+	yaffs_unhash_obj(obj);
+
+	yaffs_free_raw_obj(dev, obj);
+	dev->n_obj--;
+	dev->checkpoint_blocks_required = 0;	/* force recalculation */
+}
+
+void yaffs_handle_defered_free(struct yaffs_obj *obj)
+{
+	if (obj->defered_free)
+		yaffs_free_obj(obj);
+}
+
+static int yaffs_generic_obj_del(struct yaffs_obj *in)
+{
+
+	/* First off, invalidate the file's data in the cache, without flushing. */
+	yaffs_invalidate_whole_cache(in);
+
+	if (in->my_dev->param.is_yaffs2 && (in->parent != in->my_dev->del_dir)) {
+		/* Move to the unlinked directory so we have a record that it was deleted. */
+		yaffs_change_obj_name(in, in->my_dev->del_dir, _Y("deleted"), 0,
+				      0);
+
+	}
+
+	yaffs_remove_obj_from_dir(in);
+	yaffs_chunk_del(in->my_dev, in->hdr_chunk, 1, __LINE__);
+	in->hdr_chunk = 0;
+
+	yaffs_free_obj(in);
+	return YAFFS_OK;
+
+}
+
 static void yaffs_soft_del_file(struct yaffs_obj *obj)
 {
 	if (obj->deleted &&
@@ -1162,91 +1899,6 @@ static struct yaffs_obj *yaffs_alloc_empty_obj(struct yaffs_dev *dev)
 	return obj;
 }
 
-static struct yaffs_obj *yaffs_create_fake_dir(struct yaffs_dev *dev,
-					       int number, u32 mode)
-{
-
-	struct yaffs_obj *obj =
-	    yaffs_new_obj(dev, number, YAFFS_OBJECT_TYPE_DIRECTORY);
-	if (obj) {
-		obj->fake = 1;	/* it is fake so it might have no NAND presence... */
-		obj->rename_allowed = 0;	/* ... and we're not allowed to rename it... */
-		obj->unlink_allowed = 0;	/* ... or unlink it */
-		obj->deleted = 0;
-		obj->unlinked = 0;
-		obj->yst_mode = mode;
-		obj->my_dev = dev;
-		obj->hdr_chunk = 0;	/* Not a valid chunk. */
-	}
-
-	return obj;
-
-}
-
-static void yaffs_unhash_obj(struct yaffs_obj *obj)
-{
-	int bucket;
-	struct yaffs_dev *dev = obj->my_dev;
-
-	/* If it is still linked into the bucket list, free from the list */
-	if (!list_empty(&obj->hash_link)) {
-		list_del_init(&obj->hash_link);
-		bucket = yaffs_hash_fn(obj->obj_id);
-		dev->obj_bucket[bucket].count--;
-	}
-}
-
-/*  FreeObject frees up a Object and puts it back on the free list */
-static void yaffs_free_obj(struct yaffs_obj *obj)
-{
-	struct yaffs_dev *dev = obj->my_dev;
-
-	T(YAFFS_TRACE_OS,
-	  (TSTR("FreeObject %p inode %p" TENDSTR), obj, obj->my_inode));
-
-	if (!obj)
-		YBUG();
-	if (obj->parent)
-		YBUG();
-	if (!list_empty(&obj->siblings))
-		YBUG();
-
-	if (obj->my_inode) {
-		/* We're still hooked up to a cached inode.
-		 * Don't delete now, but mark for later deletion
-		 */
-		obj->defered_free = 1;
-		return;
-	}
-
-	yaffs_unhash_obj(obj);
-
-	yaffs_free_raw_obj(dev, obj);
-	dev->n_obj--;
-	dev->checkpoint_blocks_required = 0;	/* force recalculation */
-}
-
-void yaffs_handle_defered_free(struct yaffs_obj *obj)
-{
-	if (obj->defered_free)
-		yaffs_free_obj(obj);
-}
-
-static void yaffs_init_tnodes_and_objs(struct yaffs_dev *dev)
-{
-	int i;
-
-	dev->n_obj = 0;
-	dev->n_tnodes = 0;
-
-	yaffs_init_raw_tnodes_and_objs(dev);
-
-	for (i = 0; i < YAFFS_NOBJECT_BUCKETS; i++) {
-		INIT_LIST_HEAD(&dev->obj_bucket[i].list);
-		dev->obj_bucket[i].count = 0;
-	}
-}
-
 static int yaffs_find_nice_bucket(struct yaffs_dev *dev)
 {
 	int i;
@@ -1392,6 +2044,43 @@ struct yaffs_obj *yaffs_new_obj(struct yaffs_dev *dev, int number,
 	return the_obj;
 }
 
+static struct yaffs_obj *yaffs_create_fake_dir(struct yaffs_dev *dev,
+					       int number, u32 mode)
+{
+
+	struct yaffs_obj *obj =
+	    yaffs_new_obj(dev, number, YAFFS_OBJECT_TYPE_DIRECTORY);
+	if (obj) {
+		obj->fake = 1;	/* it is fake so it might have no NAND presence... */
+		obj->rename_allowed = 0;	/* ... and we're not allowed to rename it... */
+		obj->unlink_allowed = 0;	/* ... or unlink it */
+		obj->deleted = 0;
+		obj->unlinked = 0;
+		obj->yst_mode = mode;
+		obj->my_dev = dev;
+		obj->hdr_chunk = 0;	/* Not a valid chunk. */
+	}
+
+	return obj;
+
+}
+
+
+static void yaffs_init_tnodes_and_objs(struct yaffs_dev *dev)
+{
+	int i;
+
+	dev->n_obj = 0;
+	dev->n_tnodes = 0;
+
+	yaffs_init_raw_tnodes_and_objs(dev);
+
+	for (i = 0; i < YAFFS_NOBJECT_BUCKETS; i++) {
+		INIT_LIST_HEAD(&dev->obj_bucket[i].list);
+		dev->obj_bucket[i].count = 0;
+	}
+}
+
 struct yaffs_obj *yaffs_find_or_create_by_number(struct yaffs_dev *dev,
 						 int number,
 						 enum yaffs_obj_type type)
@@ -1416,15 +2105,78 @@ YCHAR *yaffs_clone_str(const YCHAR * str)
 	if (!str)
 		str = _Y("");
 
-	len = yaffs_strnlen(str, YAFFS_MAX_ALIAS_LENGTH);
-	new_str = YMALLOC((len + 1) * sizeof(YCHAR));
+	len = strnlen(str, YAFFS_MAX_ALIAS_LENGTH);
+	new_str = kmalloc((len + 1) * sizeof(YCHAR), GFP_NOFS);
 	if (new_str) {
-		yaffs_strncpy(new_str, str, len);
+		strncpy(new_str, str, len);
 		new_str[len] = 0;
 	}
 	return new_str;
 
 }
+/*
+ *yaffs_update_parent() handles fixing a directories mtime and ctime when a new
+ * link (ie. name) is created or deleted in the directory.
+ *
+ * ie.
+ *   create dir/a : update dir's mtime/ctime
+ *   rm dir/a:   update dir's mtime/ctime
+ *   modify dir/a: don't update dir's mtimme/ctime
+ *
+ * This can be handled immediately or defered. Defering helps reduce the number
+ * of updates when many files in a directory are changed within a brief period.
+ *
+ * If the directory updating is defered then yaffs_update_dirty_dirs must be
+ * called periodically.
+ */
+
+static void yaffs_update_parent(struct yaffs_obj *obj)
+{
+	struct yaffs_dev *dev;
+	if (!obj)
+		return;
+	dev = obj->my_dev;
+	obj->dirty = 1;
+	yaffs_load_current_time(obj, 0, 1);
+	if (dev->param.defered_dir_update) {
+		struct list_head *link = &obj->variant.dir_variant.dirty;
+
+		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);
+        }
+}
+
+void yaffs_update_dirty_dirs(struct yaffs_dev *dev)
+{
+	struct list_head *link;
+	struct yaffs_obj *obj;
+	struct yaffs_dir_var *d_s;
+	union yaffs_obj_var *o_v;
+
+	T(YAFFS_TRACE_BACKGROUND, (TSTR("Update dirty directories" TENDSTR)));
+
+	while (!list_empty(&dev->dirty_dirs)) {
+		link = dev->dirty_dirs.next;
+		list_del_init(link);
+
+		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));
+
+		if (obj->dirty)
+			yaffs_update_oh(obj, NULL, 0, 0, 0, NULL);
+	}
+}
 
 /*
  * Mknod (create) a new object.
@@ -1461,7 +2213,7 @@ static struct yaffs_obj *yaffs_create_obj(enum yaffs_obj_type type,
 
 	if (!in) {
 		if (str)
-			YFREE(str);
+			kfree(str);
 		return NULL;
 	}
 
@@ -1561,141 +2313,7 @@ struct yaffs_obj *yaffs_link_obj(struct yaffs_obj *parent, const YCHAR * name,
 
 }
 
-static int yaffs_change_obj_name(struct yaffs_obj *obj,
-				 struct yaffs_obj *new_dir,
-				 const YCHAR * new_name, int force, int shadows)
-{
-	int unlink_op;
-	int del_op;
-
-	struct yaffs_obj *existing_target;
-
-	if (new_dir == NULL)
-		new_dir = obj->parent;	/* use the old directory */
-
-	if (new_dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) {
-		T(YAFFS_TRACE_ALWAYS,
-		  (TSTR
-		   ("tragedy: yaffs_change_obj_name: new_dir is not a directory"
-		    TENDSTR)));
-		YBUG();
-	}
-
-	/* TODO: Do we need this different handling for YAFFS2 and YAFFS1?? */
-	if (obj->my_dev->param.is_yaffs2)
-		unlink_op = (new_dir == obj->my_dev->unlinked_dir);
-	else
-		unlink_op = (new_dir == obj->my_dev->unlinked_dir
-			     && obj->variant_type == YAFFS_OBJECT_TYPE_FILE);
 
-	del_op = (new_dir == obj->my_dev->del_dir);
-
-	existing_target = yaffs_find_by_name(new_dir, new_name);
-
-	/* If the object is a file going into the unlinked directory,
-	 *   then it is OK to just stuff it in since duplicate names are allowed.
-	 *   else only proceed if the new name does not exist and if we're putting
-	 *   it into a directory.
-	 */
-	if ((unlink_op ||
-	     del_op ||
-	     force ||
-	     (shadows > 0) ||
-	     !existing_target) &&
-	    new_dir->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) {
-		yaffs_set_obj_name(obj, new_name);
-		obj->dirty = 1;
-
-		yaffs_add_obj_to_dir(new_dir, obj);
-
-		if (unlink_op)
-			obj->unlinked = 1;
-
-		/* If it is a deletion then we mark it as a shrink for gc purposes. */
-		if (yaffs_update_oh(obj, new_name, 0, del_op, shadows, NULL) >=
-		    0)
-			return YAFFS_OK;
-	}
-
-	return YAFFS_FAIL;
-}
-
-
-/* Note:
- * If old_name is NULL then we take old_dir as the object to be renamed.
- */
-int yaffs_rename_obj(struct yaffs_obj *old_dir, const YCHAR * old_name,
-		     struct yaffs_obj *new_dir, const YCHAR * new_name)
-{
-	struct yaffs_obj *obj = NULL;
-	struct yaffs_obj *existing_target = NULL;
-	int force = 0;
-	int result;
-	struct yaffs_dev *dev;
-
-	if (!old_dir || old_dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY)
-		YBUG();
-	if (!new_dir || new_dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY)
-		YBUG();
-
-	dev = old_dir->my_dev;
-
-#ifdef CONFIG_YAFFS_CASE_INSENSITIVE
-	/* 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
-	 */
-	if (old_dir == new_dir && 
-		old_name && new_name && 
-		yaffs_strcmp(old_name, new_name) == 0)
-		force = 1;
-#endif
-
-	if (yaffs_strnlen(new_name, YAFFS_MAX_NAME_LENGTH + 1) >
-	    YAFFS_MAX_NAME_LENGTH)
-		/* ENAMETOOLONG */
-		return YAFFS_FAIL;
-
-	if(old_name)
-		obj = yaffs_find_by_name(old_dir, old_name);
-	else{
-		obj = old_dir;
-		old_dir = obj->parent;
-	}
-
-
-	if (obj && obj->rename_allowed) {
-
-		/* Now do the handling for an existing target, if there is one */
-
-		existing_target = yaffs_find_by_name(new_dir, new_name);
-		if (yaffs_is_non_empty_dir(existing_target)){
-			return YAFFS_FAIL;	/* ENOTEMPTY */
-		} else if (existing_target && existing_target != obj) {
-			/* Nuke the target first, using shadowing,
-			 * but only if it isn't the same object.
-			 *
-			 * Note we must disable gc otherwise it can mess up the shadowing.
-			 *
-			 */
-			dev->gc_disable = 1;
-			yaffs_change_obj_name(obj, new_dir, new_name, force,
-					      existing_target->obj_id);
-			existing_target->is_shadowed = 1;
-			yaffs_unlink_obj(existing_target);
-			dev->gc_disable = 0;
-		}
-
-		result = yaffs_change_obj_name(obj, new_dir, new_name, 1, 0);
-
-		yaffs_update_parent(old_dir);
-		if (new_dir != old_dir)
-			yaffs_update_parent(new_dir);
-
-		return result;
-	}
-	return YAFFS_FAIL;
-}
 
 /*------------------------- Block Management and Page Allocation ----------------*/
 
@@ -1709,22 +2327,24 @@ 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(struct yaffs_block_info));
+	dev->block_info =
+		kmalloc(n_blocks * sizeof(struct yaffs_block_info), GFP_NOFS);
 	if (!dev->block_info) {
 		dev->block_info =
-		    YMALLOC_ALT(n_blocks * sizeof(struct yaffs_block_info));
+		    vmalloc(n_blocks * sizeof(struct yaffs_block_info));
 		dev->block_info_alt = 1;
 	} else {
 		dev->block_info_alt = 0;
         }
 
 	if (dev->block_info) {
-		/* Set up dynamic blockinfo stuff. */
-		dev->chunk_bit_stride = (dev->param.chunks_per_block + 7) / 8;	/* round up bytes */
-		dev->chunk_bits = YMALLOC(dev->chunk_bit_stride * n_blocks);
+		/* Set up dynamic blockinfo stuff. Round up bytes. */
+		dev->chunk_bit_stride = (dev->param.chunks_per_block + 7) / 8;
+		dev->chunk_bits =
+			kmalloc(dev->chunk_bit_stride * n_blocks, GFP_NOFS);
 		if (!dev->chunk_bits) {
 			dev->chunk_bits =
-			    YMALLOC_ALT(dev->chunk_bit_stride * n_blocks);
+			    vmalloc(dev->chunk_bit_stride * n_blocks);
 			dev->chunk_bits_alt = 1;
 		} else {
 			dev->chunk_bits_alt = 0;
@@ -1744,18 +2364,18 @@ static int yaffs_init_blocks(struct yaffs_dev *dev)
 static void yaffs_deinit_blocks(struct yaffs_dev *dev)
 {
 	if (dev->block_info_alt && dev->block_info)
-		YFREE_ALT(dev->block_info);
+		vfree(dev->block_info);
 	else if (dev->block_info)
-		YFREE(dev->block_info);
+		kfree(dev->block_info);
 
 	dev->block_info_alt = 0;
 
 	dev->block_info = NULL;
 
 	if (dev->chunk_bits_alt && dev->chunk_bits)
-		YFREE_ALT(dev->chunk_bits);
+		vfree(dev->chunk_bits);
 	else if (dev->chunk_bits)
-		YFREE(dev->chunk_bits);
+		kfree(dev->chunk_bits);
 	dev->chunk_bits_alt = 0;
 	dev->chunk_bits = NULL;
 }
@@ -1837,153 +2457,7 @@ void yaffs_block_became_dirty(struct yaffs_dev *dev, int block_no)
 	}
 }
 
-static int yaffs_find_alloc_block(struct yaffs_dev *dev)
-{
-	int i;
-
-	struct yaffs_block_info *bi;
-
-	if (dev->n_erased_blocks < 1) {
-		/* Hoosterman we've got a problem.
-		 * Can't get space to gc
-		 */
-		T(YAFFS_TRACE_ERROR,
-		  (TSTR("yaffs tragedy: no more erased blocks" TENDSTR)));
-
-		return -1;
-	}
-
-	/* Find an empty block. */
-
-	for (i = dev->internal_start_block; i <= dev->internal_end_block; i++) {
-		dev->alloc_block_finder++;
-		if (dev->alloc_block_finder < dev->internal_start_block
-		    || dev->alloc_block_finder > dev->internal_end_block) {
-			dev->alloc_block_finder = dev->internal_start_block;
-		}
-
-		bi = yaffs_get_block_info(dev, dev->alloc_block_finder);
-
-		if (bi->block_state == YAFFS_BLOCK_STATE_EMPTY) {
-			bi->block_state = YAFFS_BLOCK_STATE_ALLOCATING;
-			dev->seq_number++;
-			bi->seq_number = dev->seq_number;
-			dev->n_erased_blocks--;
-			T(YAFFS_TRACE_ALLOCATE,
-			  (TSTR("Allocated block %d, seq  %d, %d left" TENDSTR),
-			   dev->alloc_block_finder, dev->seq_number,
-			   dev->n_erased_blocks));
-			return dev->alloc_block_finder;
-		}
-	}
-
-	T(YAFFS_TRACE_ALWAYS,
-	  (TSTR
-	   ("yaffs tragedy: no more erased blocks, but there should have been %d"
-	    TENDSTR), dev->n_erased_blocks));
-
-	return -1;
-}
-
-/*
- * Check if there's space to allocate...
- * Thinks.... do we need top make this ths same as yaffs_get_free_chunks()?
- */
-int yaffs_check_alloc_available(struct yaffs_dev *dev, int n_chunks)
-{
-	int reserved_chunks;
-	int reserved_blocks = dev->param.n_reserved_blocks;
-	int checkpt_blocks;
-
-	checkpt_blocks = yaffs_calc_checkpt_blocks_required(dev);
-
-	reserved_chunks =
-	    ((reserved_blocks + checkpt_blocks) * dev->param.chunks_per_block);
-
-	return (dev->n_free_chunks > (reserved_chunks + n_chunks));
-}
-
-static int yaffs_alloc_chunk(struct yaffs_dev *dev, int use_reserver,
-			     struct yaffs_block_info **block_ptr)
-{
-	int ret_val;
-	struct yaffs_block_info *bi;
-
-	if (dev->alloc_block < 0) {
-		/* Get next block to allocate off */
-		dev->alloc_block = yaffs_find_alloc_block(dev);
-		dev->alloc_page = 0;
-	}
-
-	if (!use_reserver && !yaffs_check_alloc_available(dev, 1)) {
-		/* Not enough space to allocate unless we're allowed to use the reserve. */
-		return -1;
-	}
-
-	if (dev->n_erased_blocks < dev->param.n_reserved_blocks
-	    && dev->alloc_page == 0) {
-		T(YAFFS_TRACE_ALLOCATE, (TSTR("Allocating reserve" TENDSTR)));
-	}
-
-	/* Next page please.... */
-	if (dev->alloc_block >= 0) {
-		bi = yaffs_get_block_info(dev, dev->alloc_block);
-
-		ret_val = (dev->alloc_block * dev->param.chunks_per_block) +
-		    dev->alloc_page;
-		bi->pages_in_use++;
-		yaffs_set_chunk_bit(dev, dev->alloc_block, dev->alloc_page);
-
-		dev->alloc_page++;
-
-		dev->n_free_chunks--;
-
-		/* If the block is full set the state to full */
-		if (dev->alloc_page >= dev->param.chunks_per_block) {
-			bi->block_state = YAFFS_BLOCK_STATE_FULL;
-			dev->alloc_block = -1;
-		}
-
-		if (block_ptr)
-			*block_ptr = bi;
-
-		return ret_val;
-	}
-
-	T(YAFFS_TRACE_ERROR,
-	  (TSTR("!!!!!!!!! Allocator out !!!!!!!!!!!!!!!!!" TENDSTR)));
-
-	return -1;
-}
-
-static int yaffs_get_erased_chunks(struct yaffs_dev *dev)
-{
-	int n;
-
-	n = dev->n_erased_blocks * dev->param.chunks_per_block;
-
-	if (dev->alloc_block > 0)
-		n += (dev->param.chunks_per_block - dev->alloc_page);
-
-	return n;
 
-}
-
-/*
- * yaffs_skip_rest_of_block() skips over the rest of the allocation block
- * if we don't want to write to it.
- */
-void yaffs_skip_rest_of_block(struct yaffs_dev *dev)
-{
-	if (dev->alloc_block > 0) {
-		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;
-		}
-	}
-}
 
 static int yaffs_gc_block(struct yaffs_dev *dev, int block, int whole_block)
 {
@@ -2546,206 +3020,8 @@ int yaffs_bg_gc(struct yaffs_dev *dev, unsigned urgency)
 	return erased_chunks > dev->n_free_chunks / 2;
 }
 
-/*-------------------------  TAGS --------------------------------*/
-
-static int yaffs_tags_match(const struct yaffs_ext_tags *tags, int obj_id,
-			    int chunk_obj)
-{
-	return (tags->chunk_id == chunk_obj &&
-		tags->obj_id == obj_id && !tags->is_deleted) ? 1 : 0;
-
-}
-
 /*-------------------- Data file manipulation -----------------*/
 
-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 */
-	struct yaffs_tnode *tn;
-	int the_chunk = -1;
-	struct yaffs_ext_tags local_tags;
-	int ret_val = -1;
-
-	struct yaffs_dev *dev = in->my_dev;
-
-	if (!tags) {
-		/* Passed a NULL, so use our own tags space */
-		tags = &local_tags;
-	}
-
-	tn = yaffs_find_tnode_0(dev, &in->variant.file_variant, inode_chunk);
-
-	if (tn) {
-		the_chunk = yaffs_get_group_base(dev, tn, inode_chunk);
-
-		ret_val =
-		    yaffs_find_chunk_in_group(dev, the_chunk, tags, in->obj_id,
-					      inode_chunk);
-	}
-	return ret_val;
-}
-
-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 */
-	struct yaffs_tnode *tn;
-	int the_chunk = -1;
-	struct yaffs_ext_tags local_tags;
-
-	struct yaffs_dev *dev = in->my_dev;
-	int ret_val = -1;
-
-	if (!tags) {
-		/* Passed a NULL, so use our own tags space */
-		tags = &local_tags;
-	}
-
-	tn = yaffs_find_tnode_0(dev, &in->variant.file_variant, inode_chunk);
-
-	if (tn) {
-
-		the_chunk = yaffs_get_group_base(dev, tn, inode_chunk);
-
-		ret_val =
-		    yaffs_find_chunk_in_group(dev, the_chunk, tags, in->obj_id,
-					      inode_chunk);
-
-		/* Delete the entry in the filestructure (if found) */
-		if (ret_val != -1)
-			yaffs_load_tnode_0(dev, tn, inode_chunk, 0);
-	}
-
-	return ret_val;
-}
-
-int yaffs_put_chunk_in_file(struct yaffs_obj *in, int inode_chunk,
-			    int nand_chunk, int in_scan)
-{
-	/* NB in_scan is zero unless scanning.
-	 * For forward scanning, in_scan is > 0;
-	 * for backward scanning in_scan is < 0
-	 *
-	 * nand_chunk = 0 is a dummy insert to make sure the tnodes are there.
-	 */
-
-	struct yaffs_tnode *tn;
-	struct yaffs_dev *dev = in->my_dev;
-	int existing_cunk;
-	struct yaffs_ext_tags existing_tags;
-	struct yaffs_ext_tags new_tags;
-	unsigned existing_serial, new_serial;
-
-	if (in->variant_type != YAFFS_OBJECT_TYPE_FILE) {
-		/* Just ignore an attempt at putting a chunk into a non-file during scanning
-		 * If it is not during Scanning then something went wrong!
-		 */
-		if (!in_scan) {
-			T(YAFFS_TRACE_ERROR,
-			  (TSTR
-			   ("yaffs tragedy:attempt to put data chunk into a non-file"
-			    TENDSTR)));
-			YBUG();
-		}
-
-		yaffs_chunk_del(dev, nand_chunk, 1, __LINE__);
-		return YAFFS_OK;
-	}
-
-	tn = yaffs_add_find_tnode_0(dev,
-				    &in->variant.file_variant,
-				    inode_chunk, NULL);
-	if (!tn)
-		return YAFFS_FAIL;
-
-	if (!nand_chunk)
-		/* Dummy insert, bail now */
-		return YAFFS_OK;
-
-	existing_cunk = yaffs_get_group_base(dev, tn, inode_chunk);
-
-	if (in_scan != 0) {
-		/* If we're scanning then we need to test for duplicates
-		 * NB This does not need to be efficient since it should only ever
-		 * happen when the power fails during a write, then only one
-		 * chunk should ever be affected.
-		 *
-		 * Correction for YAFFS2: This could happen quite a lot and we need to think about efficiency! TODO
-		 * Update: For backward scanning we don't need to re-read tags so this is quite cheap.
-		 */
-
-		if (existing_cunk > 0) {
-			/* NB Right now existing chunk will not be real chunk_id if the chunk group size > 1
-			 *    thus we have to do a FindChunkInFile to get the real chunk id.
-			 *
-			 * We have a duplicate now we need to decide which one to use:
-			 *
-			 * Backwards scanning YAFFS2: The old one is what we use, dump the new one.
-			 * Forward scanning YAFFS2: The new one is what we use, dump the old one.
-			 * YAFFS1: Get both sets of tags and compare serial numbers.
-			 */
-
-			if (in_scan > 0) {
-				/* Only do this for forward scanning */
-				yaffs_rd_chunk_tags_nand(dev,
-							 nand_chunk,
-							 NULL, &new_tags);
-
-				/* Do a proper find */
-				existing_cunk =
-				    yaffs_find_chunk_in_file(in, inode_chunk,
-							     &existing_tags);
-			}
-
-			if (existing_cunk <= 0) {
-				/*Hoosterman - how did this happen? */
-
-				T(YAFFS_TRACE_ERROR,
-				  (TSTR
-				   ("yaffs tragedy: existing chunk < 0 in scan"
-				    TENDSTR)));
-
-			}
-
-			/* NB The deleted flags should be false, otherwise the chunks will
-			 * not be loaded during a scan
-			 */
-
-			if (in_scan > 0) {
-				new_serial = new_tags.serial_number;
-				existing_serial = existing_tags.serial_number;
-			}
-
-			if ((in_scan > 0) &&
-			    (existing_cunk <= 0 ||
-			     ((existing_serial + 1) & 3) == new_serial)) {
-				/* Forward scanning.
-				 * Use new
-				 * Delete the old one and drop through to update the tnode
-				 */
-				yaffs_chunk_del(dev, existing_cunk, 1,
-						__LINE__);
-			} else {
-				/* Backward scanning or we want to use the existing one
-				 * Use existing.
-				 * Delete the new one and return early so that the tnode isn't changed
-				 */
-				yaffs_chunk_del(dev, nand_chunk, 1, __LINE__);
-				return YAFFS_OK;
-			}
-		}
-
-	}
-
-	if (existing_cunk == 0)
-		in->n_data_chunks++;
-
-	yaffs_load_tnode_0(dev, tn, inode_chunk, nand_chunk);
-
-	return YAFFS_OK;
-}
-
 static int yaffs_rd_data_obj(struct yaffs_obj *in, int inode_chunk, u8 * buffer)
 {
 	int nand_chunk = yaffs_find_chunk_in_file(in, inode_chunk, NULL);
@@ -2885,6 +3161,240 @@ static int yaffs_wr_data_obj(struct yaffs_obj *in, int inode_chunk,
 
 }
 
+
+
+static int yaffs_do_xattrib_mod(struct yaffs_obj *obj, int set,
+				const YCHAR * name, const void *value, int size,
+				int flags)
+{
+	struct yaffs_xattr_mod xmod;
+
+	int result;
+
+	xmod.set = set;
+	xmod.name = name;
+	xmod.data = value;
+	xmod.size = size;
+	xmod.flags = flags;
+	xmod.result = -ENOSPC;
+
+	result = yaffs_update_oh(obj, NULL, 0, 0, 0, &xmod);
+
+	if (result > 0)
+		return xmod.result;
+	else
+		return -ENOSPC;
+}
+
+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);
+	struct yaffs_dev *dev = obj->my_dev;
+	int x_size = dev->data_bytes_per_chunk - sizeof(struct yaffs_obj_hdr);
+
+	char *x_buffer = buffer + x_offs;
+
+	if (xmod->set)
+		retval =
+		    nval_set(x_buffer, x_size, xmod->name, xmod->data,
+			     xmod->size, xmod->flags);
+	else
+		retval = nval_del(x_buffer, x_size, xmod->name);
+
+	obj->has_xattr = nval_hasvalues(x_buffer, x_size);
+	obj->xattr_known = 1;
+
+	xmod->result = retval;
+
+	return retval;
+}
+
+static int yaffs_do_xattrib_fetch(struct yaffs_obj *obj, const YCHAR * name,
+				  void *value, int size)
+{
+	char *buffer = NULL;
+	int result;
+	struct yaffs_ext_tags tags;
+	struct yaffs_dev *dev = obj->my_dev;
+	int x_offs = sizeof(struct yaffs_obj_hdr);
+	int x_size = dev->data_bytes_per_chunk - sizeof(struct yaffs_obj_hdr);
+
+	char *x_buffer;
+
+	int retval = 0;
+
+	if (obj->hdr_chunk < 1)
+		return -ENODATA;
+
+	/* If we know that the object has no xattribs then don't do all the
+	 * reading and parsing.
+	 */
+	if (obj->xattr_known && !obj->has_xattr) {
+		if (name)
+			return -ENODATA;
+		else
+			return 0;
+	}
+
+	buffer = (char *)yaffs_get_temp_buffer(dev, __LINE__);
+	if (!buffer)
+		return -ENOMEM;
+
+	result =
+	    yaffs_rd_chunk_tags_nand(dev, obj->hdr_chunk, (u8 *) buffer, &tags);
+
+	if (result != YAFFS_OK)
+		retval = -ENOENT;
+	else {
+		x_buffer = buffer + x_offs;
+
+		if (!obj->xattr_known) {
+			obj->has_xattr = nval_hasvalues(x_buffer, x_size);
+			obj->xattr_known = 1;
+		}
+
+		if (name)
+			retval = nval_get(x_buffer, x_size, name, value, size);
+		else
+			retval = nval_list(x_buffer, x_size, value, size);
+	}
+	yaffs_release_temp_buffer(dev, (u8 *) buffer, __LINE__);
+	return retval;
+}
+
+int yaffs_set_xattrib(struct yaffs_obj *obj, const YCHAR * name,
+		      const void *value, int size, int flags)
+{
+	return yaffs_do_xattrib_mod(obj, 1, name, value, size, flags);
+}
+
+int yaffs_remove_xattrib(struct yaffs_obj *obj, const YCHAR * name)
+{
+	return yaffs_do_xattrib_mod(obj, 0, name, NULL, 0, 0);
+}
+
+int yaffs_get_xattrib(struct yaffs_obj *obj, const YCHAR * name, void *value,
+		      int size)
+{
+	return yaffs_do_xattrib_fetch(obj, name, value, size);
+}
+
+int yaffs_list_xattrib(struct yaffs_obj *obj, char *buffer, int size)
+{
+	return yaffs_do_xattrib_fetch(obj, NULL, buffer, size);
+}
+
+static void yaffs_check_obj_details_loaded(struct yaffs_obj *in)
+{
+	u8 *chunk_data;
+	struct yaffs_obj_hdr *oh;
+	struct yaffs_dev *dev;
+	struct yaffs_ext_tags tags;
+	int result;
+	int alloc_failed = 0;
+
+	if (!in)
+		return;
+
+	dev = in->my_dev;
+
+	if (in->lazy_loaded && in->hdr_chunk > 0) {
+		in->lazy_loaded = 0;
+		chunk_data = yaffs_get_temp_buffer(dev, __LINE__);
+
+		result =
+		    yaffs_rd_chunk_tags_nand(dev, in->hdr_chunk, chunk_data,
+					     &tags);
+		oh = (struct yaffs_obj_hdr *)chunk_data;
+
+		in->yst_mode = oh->yst_mode;
+		yaffs_load_attribs(in, oh);
+		yaffs_set_obj_name_from_oh(in, oh);
+
+		if (in->variant_type == YAFFS_OBJECT_TYPE_SYMLINK) {
+			in->variant.symlink_variant.alias =
+			    yaffs_clone_str(oh->alias);
+			if (!in->variant.symlink_variant.alias)
+				alloc_failed = 1;	/* Not returned to caller */
+		}
+
+		yaffs_release_temp_buffer(dev, chunk_data, __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, so 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 do a unicode to ascii conversion */
+			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 {
+			/* It is a 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);
+        }
+
+}
+
 /* UpdateObjectHeader updates the header on NAND for an object.
  * If name is not NULL, then that new name is used.
  */
@@ -2910,7 +3420,7 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR * name, int force,
 
 	struct yaffs_obj_hdr *oh = NULL;
 
-	yaffs_strcpy(old_name, _Y("silly old name"));
+	strcpy(old_name, _Y("silly old name"));
 
 	if (!in->fake || in == dev->root_dir ||	/* The root_dir should also be saved */
 	    force || xmod) {
@@ -2981,7 +3491,7 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR * name, int force,
 			alias = in->variant.symlink_variant.alias;
 			if (!alias)
 				alias = _Y("no alias");
-			yaffs_strncpy(oh->alias, alias, YAFFS_MAX_ALIAS_LENGTH);
+			strncpy(oh->alias, alias, YAFFS_MAX_ALIAS_LENGTH);
 			oh->alias[YAFFS_MAX_ALIAS_LENGTH] = 0;
 			break;
 		}
@@ -3047,261 +3557,6 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR * name, int force,
 	return ret_val;
 }
 
-/*------------------------ Short Operations Cache ----------------------------------------
- *   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 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.
- */
-
-static int yaffs_obj_cache_dirty(struct yaffs_obj *obj)
-{
-	struct yaffs_dev *dev = obj->my_dev;
-	int i;
-	struct yaffs_cache *cache;
-	int n_caches = obj->my_dev->param.n_caches;
-
-	for (i = 0; i < n_caches; i++) {
-		cache = &dev->cache[i];
-		if (cache->object == obj && cache->dirty)
-			return 1;
-	}
-
-	return 0;
-}
-
-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;
-	struct yaffs_cache *cache;
-	int chunk_written = 0;
-	int n_caches = obj->my_dev->param.n_caches;
-
-	if (n_caches > 0) {
-		do {
-			cache = NULL;
-
-			/* Find the dirty cache for this object with the lowest chunk id. */
-			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. */
-			T(YAFFS_TRACE_ERROR,
-			  (TSTR
-			   ("yaffs tragedy: no space during cache write"
-			    TENDSTR)));
-
-		}
-	}
-
-}
-
-/*yaffs_flush_whole_cache(dev)
- *
- *
- */
-
-void yaffs_flush_whole_cache(struct yaffs_dev *dev)
-{
-	struct yaffs_obj *obj;
-	int n_caches = dev->param.n_caches;
-	int i;
-
-	/* Find a dirty object in the cache and flush it...
-	 * until there are no further dirty objects.
-	 */
-	do {
-		obj = NULL;
-		for (i = 0; i < n_caches && !obj; i++) {
-			if (dev->cache[i].object && dev->cache[i].dirty)
-				obj = dev->cache[i].object;
-
-		}
-		if (obj)
-			yaffs_flush_file_cache(obj);
-
-	} while (obj);
-
-}
-
-/* Grab us a 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.
- */
-static struct yaffs_cache *yaffs_grab_chunk_worker(struct yaffs_dev *dev)
-{
-	int i;
-
-	if (dev->param.n_caches > 0) {
-		for (i = 0; i < dev->param.n_caches; i++) {
-			if (!dev->cache[i].object)
-				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 > 0) {
-		/* Try find a non-dirty one... */
-
-		cache = yaffs_grab_chunk_worker(dev);
-
-		if (!cache) {
-			/* They were all dirty, find the last recently used object and flush
-			 * its cache, then  find again.
-			 * NB what's here is not very accurate, we actually flush the object
-			 * the last recently used page.
-			 */
-
-			/* With locking we can't assume we can use entry zero */
-
-			the_obj = NULL;
-			usage = -1;
-			cache = NULL;
-			pushout = -1;
-
-			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);
-			}
-
-		}
-		return cache;
-	} else {
-		return NULL;
-        }
-}
-
-/* Find a cached chunk */
-static struct yaffs_cache *yaffs_find_chunk_cache(const struct yaffs_obj *obj,
-						  int chunk_id)
-{
-	struct yaffs_dev *dev = obj->my_dev;
-	int i;
-	if (dev->param.n_caches > 0) {
-		for (i = 0; i < dev->param.n_caches; i++) {
-			if (dev->cache[i].object == obj &&
-			    dev->cache[i].chunk_id == chunk_id) {
-				dev->cache_hits++;
-
-				return &dev->cache[i];
-			}
-		}
-	}
-	return NULL;
-}
-
-/* Mark the chunk for the least recently used algorithym */
-static void yaffs_use_cache(struct yaffs_dev *dev, struct yaffs_cache *cache,
-			    int is_write)
-{
-
-	if (dev->param.n_caches > 0) {
-		if (dev->cache_last_use < 0 || dev->cache_last_use > 100000000) {
-			/* Reset the cache usages */
-			int i;
-			for (i = 1; i < dev->param.n_caches; i++)
-				dev->cache[i].last_use = 0;
-
-			dev->cache_last_use = 0;
-		}
-
-		dev->cache_last_use++;
-
-		cache->last_use = dev->cache_last_use;
-
-		if (is_write)
-			cache->dirty = 1;
-	}
-}
-
-/* Invalidate a single cache page.
- * Do this when a whole page gets written,
- * ie the short cache for this page is no longer valid.
- */
-static void yaffs_invalidate_chunk_cache(struct yaffs_obj *object, int chunk_id)
-{
-	if (object->my_dev->param.n_caches > 0) {
-		struct yaffs_cache *cache =
-		    yaffs_find_chunk_cache(object, chunk_id);
-
-		if (cache)
-			cache->object = NULL;
-	}
-}
-
-/* Invalidate all the cache pages associated with this object
- * Do this whenever ther file is deleted or resized.
- */
-static void yaffs_invalidate_whole_cache(struct yaffs_obj *in)
-{
-	int i;
-	struct yaffs_dev *dev = in->my_dev;
-
-	if (dev->param.n_caches > 0) {
-		/* Invalidate it. */
-		for (i = 0; i < dev->param.n_caches; i++) {
-			if (dev->cache[i].object == in)
-				dev->cache[i].object = NULL;
-		}
-	}
-}
-
 /*--------------------- File read/write ------------------------
  * Read and write have very similar structures.
  * In general the read/write has three parts to it
@@ -3715,27 +3970,6 @@ int yaffs_flush_file(struct yaffs_obj *in, int update_time, int data_sync)
 
 }
 
-static int yaffs_generic_obj_del(struct yaffs_obj *in)
-{
-
-	/* First off, invalidate the file's data in the cache, without flushing. */
-	yaffs_invalidate_whole_cache(in);
-
-	if (in->my_dev->param.is_yaffs2 && (in->parent != in->my_dev->del_dir)) {
-		/* Move to the unlinked directory so we have a record that it was deleted. */
-		yaffs_change_obj_name(in, in->my_dev->del_dir, _Y("deleted"), 0,
-				      0);
-
-	}
-
-	yaffs_remove_obj_from_dir(in);
-	yaffs_chunk_del(in->my_dev, in->hdr_chunk, 1, __LINE__);
-	in->hdr_chunk = 0;
-
-	yaffs_free_obj(in);
-	return YAFFS_OK;
-
-}
 
 /* yaffs_del_file deletes the whole file data
  * and the inode associated with the file.
@@ -3826,7 +4060,7 @@ static int yaffs_del_dir(struct yaffs_obj *obj)
 static int yaffs_del_symlink(struct yaffs_obj *in)
 {
 	if (in->variant.symlink_variant.alias)
-		YFREE(in->variant.symlink_variant.alias);
+		kfree(in->variant.symlink_variant.alias);
 	in->variant.symlink_variant.alias = NULL;
 
 	return yaffs_generic_obj_del(in);
@@ -3971,6 +4205,82 @@ int yaffs_unlinker(struct yaffs_obj *dir, const YCHAR * name)
 	return yaffs_unlink_obj(obj);
 }
 
+/* Note:
+ * If old_name is NULL then we take old_dir as the object to be renamed.
+ */
+int yaffs_rename_obj(struct yaffs_obj *old_dir, const YCHAR * old_name,
+		     struct yaffs_obj *new_dir, const YCHAR * new_name)
+{
+	struct yaffs_obj *obj = NULL;
+	struct yaffs_obj *existing_target = NULL;
+	int force = 0;
+	int result;
+	struct yaffs_dev *dev;
+
+	if (!old_dir || old_dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY)
+		YBUG();
+	if (!new_dir || new_dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY)
+		YBUG();
+
+	dev = old_dir->my_dev;
+
+#ifdef CONFIG_YAFFS_CASE_INSENSITIVE
+	/* 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
+	 */
+	if (old_dir == new_dir && 
+		old_name && new_name && 
+		strcmp(old_name, new_name) == 0)
+		force = 1;
+#endif
+
+	if (strnlen(new_name, YAFFS_MAX_NAME_LENGTH + 1) >
+	    YAFFS_MAX_NAME_LENGTH)
+		/* ENAMETOOLONG */
+		return YAFFS_FAIL;
+
+	if(old_name)
+		obj = yaffs_find_by_name(old_dir, old_name);
+	else{
+		obj = old_dir;
+		old_dir = obj->parent;
+	}
+
+
+	if (obj && obj->rename_allowed) {
+
+		/* Now do the handling for an existing target, if there is one */
+
+		existing_target = yaffs_find_by_name(new_dir, new_name);
+		if (yaffs_is_non_empty_dir(existing_target)){
+			return YAFFS_FAIL;	/* ENOTEMPTY */
+		} else if (existing_target && existing_target != obj) {
+			/* Nuke the target first, using shadowing,
+			 * but only if it isn't the same object.
+			 *
+			 * Note we must disable gc otherwise it can mess up the shadowing.
+			 *
+			 */
+			dev->gc_disable = 1;
+			yaffs_change_obj_name(obj, new_dir, new_name, force,
+					      existing_target->obj_id);
+			existing_target->is_shadowed = 1;
+			yaffs_unlink_obj(existing_target);
+			dev->gc_disable = 0;
+		}
+
+		result = yaffs_change_obj_name(obj, new_dir, new_name, 1, 0);
+
+		yaffs_update_parent(old_dir);
+		if (new_dir != old_dir)
+			yaffs_update_parent(new_dir);
+
+		return result;
+	}
+	return YAFFS_FAIL;
+}
+
 /*----------------------- Initialisation Scanning ---------------------- */
 
 void yaffs_handle_shadowed_obj(struct yaffs_dev *dev, int obj_id,
@@ -4188,170 +4498,6 @@ static void yaffs_empty_l_n_f(struct yaffs_dev *dev)
 	yaffs_del_dir_contents(dev->lost_n_found);
 }
 
-static void yaffs_check_obj_details_loaded(struct yaffs_obj *in)
-{
-	u8 *chunk_data;
-	struct yaffs_obj_hdr *oh;
-	struct yaffs_dev *dev;
-	struct yaffs_ext_tags tags;
-	int result;
-	int alloc_failed = 0;
-
-	if (!in)
-		return;
-
-	dev = in->my_dev;
-
-	if (in->lazy_loaded && in->hdr_chunk > 0) {
-		in->lazy_loaded = 0;
-		chunk_data = yaffs_get_temp_buffer(dev, __LINE__);
-
-		result =
-		    yaffs_rd_chunk_tags_nand(dev, in->hdr_chunk, chunk_data,
-					     &tags);
-		oh = (struct yaffs_obj_hdr *)chunk_data;
-
-		in->yst_mode = oh->yst_mode;
-		yaffs_load_attribs(in, oh);
-		yaffs_set_obj_name_from_oh(in, oh);
-
-		if (in->variant_type == YAFFS_OBJECT_TYPE_SYMLINK) {
-			in->variant.symlink_variant.alias =
-			    yaffs_clone_str(oh->alias);
-			if (!in->variant.symlink_variant.alias)
-				alloc_failed = 1;	/* Not returned to caller */
-		}
-
-		yaffs_release_temp_buffer(dev, chunk_data, __LINE__);
-	}
-}
-
-/*------------------------------  Directory Functions ----------------------------- */
-
-/*
- *yaffs_update_parent() handles fixing a directories mtime and ctime when a new
- * link (ie. name) is created or deleted in the directory.
- *
- * ie.
- *   create dir/a : update dir's mtime/ctime
- *   rm dir/a:   update dir's mtime/ctime
- *   modify dir/a: don't update dir's mtimme/ctime
- *
- * This can be handled immediately or defered. Defering helps reduce the number
- * of updates when many files in a directory are changed within a brief period.
- *
- * If the directory updating is defered then yaffs_update_dirty_dirs must be
- * called periodically.
- */
-
-static void yaffs_update_parent(struct yaffs_obj *obj)
-{
-	struct yaffs_dev *dev;
-	if (!obj)
-		return;
-	dev = obj->my_dev;
-	obj->dirty = 1;
-	yaffs_load_current_time(obj, 0, 1);
-	if (dev->param.defered_dir_update) {
-		struct list_head *link = &obj->variant.dir_variant.dirty;
-
-		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);
-        }
-}
-
-void yaffs_update_dirty_dirs(struct yaffs_dev *dev)
-{
-	struct list_head *link;
-	struct yaffs_obj *obj;
-	struct yaffs_dir_var *d_s;
-	union yaffs_obj_var *o_v;
-
-	T(YAFFS_TRACE_BACKGROUND, (TSTR("Update dirty directories" TENDSTR)));
-
-	while (!list_empty(&dev->dirty_dirs)) {
-		link = dev->dirty_dirs.next;
-		list_del_init(link);
-
-		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));
-
-		if (obj->dirty)
-			yaffs_update_oh(obj, NULL, 0, 0, 0, NULL);
-	}
-}
-
-static void yaffs_remove_obj_from_dir(struct yaffs_obj *obj)
-{
-	struct yaffs_dev *dev = obj->my_dev;
-	struct yaffs_obj *parent;
-
-	yaffs_verify_obj_in_dir(obj);
-	parent = obj->parent;
-
-	yaffs_verify_dir(parent);
-
-	if (dev && dev->param.remove_obj_fn)
-		dev->param.remove_obj_fn(obj);
-
-	list_del_init(&obj->siblings);
-	obj->parent = NULL;
-
-	yaffs_verify_dir(parent);
-}
-
-void yaffs_add_obj_to_dir(struct yaffs_obj *directory, struct yaffs_obj *obj)
-{
-	if (!directory) {
-		T(YAFFS_TRACE_ALWAYS,
-		  (TSTR
-		   ("tragedy: Trying to add an object to a null pointer directory"
-		    TENDSTR)));
-		YBUG();
-		return;
-	}
-	if (directory->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) {
-		T(YAFFS_TRACE_ALWAYS,
-		  (TSTR
-		   ("tragedy: Trying to add an object to a non-directory"
-		    TENDSTR)));
-		YBUG();
-	}
-
-	if (obj->siblings.prev == NULL) {
-		/* Not initialised */
-		YBUG();
-	}
-
-	yaffs_verify_dir(directory);
-
-	yaffs_remove_obj_from_dir(obj);
-
-	/* Now add it */
-	list_add(&obj->siblings, &directory->variant.dir_variant.children);
-	obj->parent = directory;
-
-	if (directory == obj->my_dev->unlinked_dir
-	    || directory == obj->my_dev->del_dir) {
-		obj->unlinked = 1;
-		obj->my_dev->n_unlinked_files++;
-		obj->rename_allowed = 0;
-	}
-
-	yaffs_verify_dir(directory);
-	yaffs_verify_obj_in_dir(obj);
-}
 
 struct yaffs_obj *yaffs_find_by_name(struct yaffs_obj *directory,
 				     const YCHAR * name)
@@ -4393,16 +4539,16 @@ struct yaffs_obj *yaffs_find_by_name(struct yaffs_obj *directory,
 
 			/* Special case for lost-n-found */
 			if (l->obj_id == YAFFS_OBJECTID_LOSTNFOUND) {
-				if (!yaffs_strcmp(name, YAFFS_LOSTNFOUND_NAME))
+				if (!strcmp(name, YAFFS_LOSTNFOUND_NAME))
 					return l;
-			} else if (yaffs_sum_cmp(l->sum, sum)
+			} else if (l->sum == sum
 				   || l->hdr_chunk <= 0) {
 				/* LostnFound chunk called Objxxx
 				 * Do a real check
 				 */
 				yaffs_get_obj_name(l, buffer,
 						   YAFFS_MAX_NAME_LENGTH + 1);
-				if (yaffs_strncmp
+				if (strncmp
 				    (name, buffer, YAFFS_MAX_NAME_LENGTH) == 0)
 					return l;
 			}
@@ -4449,7 +4595,7 @@ static void yaffs_fix_null_name(struct yaffs_obj *obj, YCHAR * name,
 				int buffer_size)
 {
 	/* Create an object name if we could not find one. */
-	if (yaffs_strnlen(name, YAFFS_MAX_NAME_LENGTH) == 0) {
+	if (strnlen(name, YAFFS_MAX_NAME_LENGTH) == 0) {
 		YCHAR local_name[20];
 		YCHAR num_string[20];
 		YCHAR *x = &num_string[19];
@@ -4461,83 +4607,12 @@ static void yaffs_fix_null_name(struct yaffs_obj *obj, YCHAR * name,
 			v /= 10;
 		}
 		/* make up a name */
-		yaffs_strcpy(local_name, YAFFS_LOSTNFOUND_PREFIX);
-		yaffs_strcat(local_name, x);
-		yaffs_strncpy(name, local_name, buffer_size - 1);
+		strcpy(local_name, YAFFS_LOSTNFOUND_PREFIX);
+		strcat(local_name, x);
+		strncpy(name, local_name, buffer_size - 1);
 	}
 }
 
-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, so 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 {
-			yaffs_strncpy(name, oh_name + 1, buff_size - 1);
-                }
-	} else {
-#else
-        {
-#endif
-		yaffs_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 do a unicode to ascii conversion */
-			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 {
-			/* It is a unicode name, so save starting at the second YCHAR */
-			*oh_name = 0;
-			yaffs_strncpy(oh_name + 1, name,
-				      YAFFS_MAX_NAME_LENGTH - 2);
-		}
-	} else {
-#else
-        {
-#endif
-		yaffs_strncpy(oh_name, name, YAFFS_MAX_NAME_LENGTH - 1);
-        }
-
-}
-
 int yaffs_get_obj_name(struct yaffs_obj *obj, YCHAR * name, int buffer_size)
 {
 	memset(name, 0, buffer_size * sizeof(YCHAR));
@@ -4545,11 +4620,11 @@ int yaffs_get_obj_name(struct yaffs_obj *obj, YCHAR * name, int buffer_size)
 	yaffs_check_obj_details_loaded(obj);
 
 	if (obj->obj_id == YAFFS_OBJECTID_LOSTNFOUND) {
-		yaffs_strncpy(name, YAFFS_LOSTNFOUND_NAME, buffer_size - 1);
+		strncpy(name, YAFFS_LOSTNFOUND_NAME, buffer_size - 1);
 	}
 #ifndef CONFIG_YAFFS_NO_SHORT_NAMES
 	else if (obj->short_name[0]) {
-		yaffs_strcpy(name, obj->short_name);
+		strcpy(name, obj->short_name);
 	}
 #endif
 	else if (obj->hdr_chunk > 0) {
@@ -4573,7 +4648,7 @@ int yaffs_get_obj_name(struct yaffs_obj *obj, YCHAR * name, int buffer_size)
 
 	yaffs_fix_null_name(obj, name, buffer_size);
 
-	return yaffs_strnlen(name, YAFFS_MAX_NAME_LENGTH);
+	return strnlen(name, YAFFS_MAX_NAME_LENGTH);
 }
 
 int yaffs_get_obj_length(struct yaffs_obj *obj)
@@ -4586,7 +4661,7 @@ int yaffs_get_obj_length(struct yaffs_obj *obj)
 	if (obj->variant_type == YAFFS_OBJECT_TYPE_SYMLINK) {
 		if (!obj->variant.symlink_variant.alias)
 			return 0;
-		return yaffs_strnlen(obj->variant.symlink_variant.alias,
+		return strnlen(obj->variant.symlink_variant.alias,
 				     YAFFS_MAX_ALIAS_LENGTH);
 	} else {
 		/* Only a directory should drop through to here */
@@ -4656,130 +4731,7 @@ YCHAR *yaffs_get_symlink_alias(struct yaffs_obj *obj)
 		return yaffs_clone_str(_Y(""));
 }
 
-static int yaffs_do_xattrib_mod(struct yaffs_obj *obj, int set,
-				const YCHAR * name, const void *value, int size,
-				int flags)
-{
-	struct yaffs_xattr_mod xmod;
-
-	int result;
-
-	xmod.set = set;
-	xmod.name = name;
-	xmod.data = value;
-	xmod.size = size;
-	xmod.flags = flags;
-	xmod.result = -ENOSPC;
-
-	result = yaffs_update_oh(obj, NULL, 0, 0, 0, &xmod);
-
-	if (result > 0)
-		return xmod.result;
-	else
-		return -ENOSPC;
-}
-
-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);
-	struct yaffs_dev *dev = obj->my_dev;
-	int x_size = dev->data_bytes_per_chunk - sizeof(struct yaffs_obj_hdr);
-
-	char *x_buffer = buffer + x_offs;
-
-	if (xmod->set)
-		retval =
-		    nval_set(x_buffer, x_size, xmod->name, xmod->data,
-			     xmod->size, xmod->flags);
-	else
-		retval = nval_del(x_buffer, x_size, xmod->name);
-
-	obj->has_xattr = nval_hasvalues(x_buffer, x_size);
-	obj->xattr_known = 1;
-
-	xmod->result = retval;
-
-	return retval;
-}
-
-static int yaffs_do_xattrib_fetch(struct yaffs_obj *obj, const YCHAR * name,
-				  void *value, int size)
-{
-	char *buffer = NULL;
-	int result;
-	struct yaffs_ext_tags tags;
-	struct yaffs_dev *dev = obj->my_dev;
-	int x_offs = sizeof(struct yaffs_obj_hdr);
-	int x_size = dev->data_bytes_per_chunk - sizeof(struct yaffs_obj_hdr);
-
-	char *x_buffer;
-
-	int retval = 0;
-
-	if (obj->hdr_chunk < 1)
-		return -ENODATA;
-
-	/* If we know that the object has no xattribs then don't do all the
-	 * reading and parsing.
-	 */
-	if (obj->xattr_known && !obj->has_xattr) {
-		if (name)
-			return -ENODATA;
-		else
-			return 0;
-	}
-
-	buffer = (char *)yaffs_get_temp_buffer(dev, __LINE__);
-	if (!buffer)
-		return -ENOMEM;
-
-	result =
-	    yaffs_rd_chunk_tags_nand(dev, obj->hdr_chunk, (u8 *) buffer, &tags);
-
-	if (result != YAFFS_OK)
-		retval = -ENOENT;
-	else {
-		x_buffer = buffer + x_offs;
-
-		if (!obj->xattr_known) {
-			obj->has_xattr = nval_hasvalues(x_buffer, x_size);
-			obj->xattr_known = 1;
-		}
-
-		if (name)
-			retval = nval_get(x_buffer, x_size, name, value, size);
-		else
-			retval = nval_list(x_buffer, x_size, value, size);
-	}
-	yaffs_release_temp_buffer(dev, (u8 *) buffer, __LINE__);
-	return retval;
-}
-
-int yaffs_set_xattrib(struct yaffs_obj *obj, const YCHAR * name,
-		      const void *value, int size, int flags)
-{
-	return yaffs_do_xattrib_mod(obj, 1, name, value, size, flags);
-}
-
-int yaffs_remove_xattrib(struct yaffs_obj *obj, const YCHAR * name)
-{
-	return yaffs_do_xattrib_mod(obj, 0, name, NULL, 0, 0);
-}
-
-int yaffs_get_xattrib(struct yaffs_obj *obj, const YCHAR * name, void *value,
-		      int size)
-{
-	return yaffs_do_xattrib_fetch(obj, name, value, size);
-}
-
-int yaffs_list_xattrib(struct yaffs_obj *obj, char *buffer, int size)
-{
-	return yaffs_do_xattrib_fetch(obj, NULL, buffer, size);
-}
-
-/*---------------------------- Initialisation code -------------------------------------- */
+/*--------------------------- Initialisation code -------------------------- */
 
 static int yaffs_check_dev_fns(const struct yaffs_dev *dev)
 {
@@ -5022,7 +4974,7 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
 		if (dev->param.n_caches > YAFFS_MAX_SHORT_OP_CACHES)
 			dev->param.n_caches = YAFFS_MAX_SHORT_OP_CACHES;
 
-		dev->cache = YMALLOC(cache_bytes);
+		dev->cache = kmalloc(cache_bytes, GFP_NOFS);
 
 		buf = (u8 *) dev->cache;
 
@@ -5034,7 +4986,7 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
 			dev->cache[i].last_use = 0;
 			dev->cache[i].dirty = 0;
 			dev->cache[i].data = buf =
-			    YMALLOC_DMA(dev->param.total_bytes_per_chunk);
+			    kmalloc(dev->param.total_bytes_per_chunk, GFP_NOFS);
 		}
 		if (!buf)
 			init_failed = 1;
@@ -5046,7 +4998,8 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
 
 	if (!init_failed) {
 		dev->gc_cleanup_list =
-		    YMALLOC(dev->param.chunks_per_block * sizeof(u32));
+		    kmalloc(dev->param.chunks_per_block * sizeof(u32),
+					GFP_NOFS);
 		if (!dev->gc_cleanup_list)
 			init_failed = 1;
 	}
@@ -5152,18 +5105,18 @@ void yaffs_deinitialise(struct yaffs_dev *dev)
 
 			for (i = 0; i < dev->param.n_caches; i++) {
 				if (dev->cache[i].data)
-					YFREE(dev->cache[i].data);
+					kfree(dev->cache[i].data);
 				dev->cache[i].data = NULL;
 			}
 
-			YFREE(dev->cache);
+			kfree(dev->cache);
 			dev->cache = NULL;
 		}
 
-		YFREE(dev->gc_cleanup_list);
+		kfree(dev->gc_cleanup_list);
 
 		for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++)
-			YFREE(dev->temp_buffer[i].buffer);
+			kfree(dev->temp_buffer[i].buffer);
 
 		dev->is_mounted = 0;
 
diff --git a/yaffs_nameval.c b/yaffs_nameval.c
index d8c548a..daa36f9 100644
--- a/yaffs_nameval.c
+++ b/yaffs_nameval.c
@@ -37,7 +37,7 @@ static int nval_find(const char *xb, int xb_size, const YCHAR * name,
 
 	memcpy(&size, xb, sizeof(int));
 	while (size > 0 && (size < xb_size) && (pos + size < xb_size)) {
-		if (yaffs_strncmp
+		if (strncmp
 		    ((YCHAR *) (xb + pos + sizeof(int)), name, size) == 0) {
 			if (exist_size)
 				*exist_size = size;
@@ -90,7 +90,7 @@ int nval_set(char *xb, int xb_size, const YCHAR * name, const char *buf,
 	     int bsize, int flags)
 {
 	int pos;
-	int namelen = yaffs_strnlen(name, xb_size);
+	int namelen = strnlen(name, xb_size);
 	int reclen;
 	int size_exist = 0;
 	int space;
@@ -120,7 +120,7 @@ int nval_set(char *xb, int xb_size, const YCHAR * name, const char *buf,
 
 	memcpy(xb + pos, &reclen, sizeof(int));
 	pos += sizeof(int);
-	yaffs_strncpy((YCHAR *) (xb + pos), name, reclen);
+	strncpy((YCHAR *) (xb + pos), name, reclen);
 	pos += (namelen + 1);
 	memcpy(xb + pos, buf, bsize);
 	return 0;
@@ -172,7 +172,7 @@ int nval_list(const char *xb, int xb_size, char *buf, int bsize)
 	       && !filled) {
 		pos += sizeof(int);
 		size -= sizeof(int);
-		name_len = yaffs_strnlen((YCHAR *) (xb + pos), size);
+		name_len = strnlen((YCHAR *) (xb + pos), size);
 		if (ncopied + name_len + 1 < bsize) {
 			memcpy(buf, xb + pos, name_len * sizeof(YCHAR));
 			buf += name_len;
diff --git a/yaffs_vfs_multi.c b/yaffs_vfs_multi.c
index 8aa3fd4..074a285 100644
--- a/yaffs_vfs_multi.c
+++ b/yaffs_vfs_multi.c
@@ -623,7 +623,7 @@ static struct yaffs_search_context *yaffs_new_search(struct yaffs_obj *dir)
 {
 	struct yaffs_dev *dev = dir->my_dev;
 	struct yaffs_search_context *sc =
-	    YMALLOC(sizeof(struct yaffs_search_context));
+	    kmalloc(sizeof(struct yaffs_search_context), GFP_NOFS);
 	if (sc) {
 		sc->dir_obj = dir;
 		sc->dev = dev;
@@ -646,7 +646,7 @@ static void yaffs_search_end(struct yaffs_search_context *sc)
 {
 	if (sc) {
 		list_del(&sc->others);
-		YFREE(sc);
+		kfree(sc);
 	}
 }
 
@@ -2516,7 +2516,7 @@ static void yaffs_put_super(struct super_block *sb)
 	mutex_unlock(&yaffs_context_lock);
 
 	if (yaffs_dev_to_lc(dev)->spare_buffer) {
-		YFREE(yaffs_dev_to_lc(dev)->spare_buffer);
+		kfree(yaffs_dev_to_lc(dev)->spare_buffer);
 		yaffs_dev_to_lc(dev)->spare_buffer = NULL;
 	}
 
@@ -2897,7 +2897,8 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
 		param->read_chunk_tags_fn = nandmtd2_read_chunk_tags;
 		param->bad_block_fn = nandmtd2_mark_block_bad;
 		param->query_block_fn = nandmtd2_query_block;
-		yaffs_dev_to_lc(dev)->spare_buffer = YMALLOC(mtd->oobsize);
+		yaffs_dev_to_lc(dev)->spare_buffer = 
+				kmalloc(mtd->oobsize, GFP_NOFS);
 		param->is_yaffs2 = 1;
 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
 		param->total_bytes_per_chunk = mtd->writesize;
diff --git a/yaffs_vfs_single.c b/yaffs_vfs_single.c
index 89c03fd..df333cc 100644
--- a/yaffs_vfs_single.c
+++ b/yaffs_vfs_single.c
@@ -105,9 +105,6 @@ module_param(yaffs_auto_checkpoint, uint, 0644);
 module_param(yaffs_gc_control, uint, 0644);
 module_param(yaffs_bg_enable, uint, 0644);
 
-#define Y_IGET(sb, inum) yaffs_iget((sb), (inum))
-
-static struct inode *yaffs_iget(struct super_block *sb, unsigned long ino);
 
 #define yaffs_inode_to_obj_lv(iptr) ((iptr)->i_private)
 #define yaffs_inode_to_obj(iptr) ((struct yaffs_obj *)(yaffs_inode_to_obj_lv(iptr)))
@@ -118,251 +115,573 @@ static struct inode *yaffs_iget(struct super_block *sb, unsigned long ino);
 			(dir)->i_ctime = (dir)->i_mtime = CURRENT_TIME; \
 		} while(0)
 
-static void yaffs_put_super(struct super_block *sb);
-
-static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n,
-				loff_t * pos);
-static ssize_t yaffs_hold_space(struct file *f);
-static void yaffs_release_space(struct file *f);
 
-static int yaffs_file_flush(struct file *file, fl_owner_t id);
+static unsigned yaffs_gc_control_callback(struct yaffs_dev *dev)
+{
+	return yaffs_gc_control;
+}
 
-static int yaffs_sync_object(struct file *file, int datasync);
+static void yaffs_gross_lock(struct yaffs_dev *dev)
+{
+	T(YAFFS_TRACE_LOCK, (TSTR("yaffs locking %p\n"), current));
+	mutex_lock(&(yaffs_dev_to_lc(dev)->gross_lock));
+	T(YAFFS_TRACE_LOCK, (TSTR("yaffs locked %p\n"), current));
+}
 
-static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir);
+static void yaffs_gross_unlock(struct yaffs_dev *dev)
+{
+	T(YAFFS_TRACE_LOCK, (TSTR("yaffs unlocking %p\n"), current));
+	mutex_unlock(&(yaffs_dev_to_lc(dev)->gross_lock));
+}
 
-static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode,
-			struct nameidata *n);
-static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry,
-				   struct nameidata *n);
-static int yaffs_link(struct dentry *old_dentry, struct inode *dir,
-		      struct dentry *dentry);
-static int yaffs_unlink(struct inode *dir, struct dentry *dentry);
-static int yaffs_symlink(struct inode *dir, struct dentry *dentry,
-			 const char *symname);
-static int yaffs_mkdir(struct inode *dir, struct dentry *dentry, int mode);
+static void yaffs_fill_inode_from_obj(struct inode *inode,
+				      struct yaffs_obj *obj);
 
-static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
-		       dev_t dev);
-static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry,
-			struct inode *new_dir, struct dentry *new_dentry);
-static int yaffs_setattr(struct dentry *dentry, struct iattr *attr);
+static struct inode *yaffs_iget(struct super_block *sb, unsigned long ino)
+{
+	struct inode *inode;
+	struct yaffs_obj *obj;
+	struct yaffs_dev *dev = yaffs_super_to_dev(sb);
 
-static int yaffs_sync_fs(struct super_block *sb, int wait);
-static void yaffs_write_super(struct super_block *sb);
+	T(YAFFS_TRACE_OS, (TSTR("yaffs_iget for %lu\n"), ino));
 
-static int yaffs_statfs(struct dentry *dentry, struct kstatfs *buf);
+	inode = iget_locked(sb, ino);
+	if (!inode)
+		return ERR_PTR(-ENOMEM);
+	if (!(inode->i_state & I_NEW))
+		return inode;
 
-#ifdef YAFFS_HAS_PUT_INODE
-static void yaffs_put_inode(struct inode *inode);
-#endif
+	/* NB This is called as a side effect of other functions, but
+	 * we had to release the lock to prevent deadlocks, so
+	 * need to lock again.
+	 */
 
-static void yaffs_evict_inode(struct inode *);
+	yaffs_gross_lock(dev);
 
-static int yaffs_readpage(struct file *file, struct page *page);
-static int yaffs_writepage(struct page *page, struct writeback_control *wbc);
+	obj = yaffs_find_by_number(dev, inode->i_ino);
 
-#ifdef CONFIG_YAFFS_XATTR
-static int yaffs_setxattr(struct dentry *dentry, const char *name,
-		   const void *value, size_t size, int flags);
-static ssize_t yaffs_getxattr(struct dentry *dentry, const char *name, void *buff,
-		       size_t size);
-static int yaffs_removexattr(struct dentry *dentry, const char *name);
-static ssize_t yaffs_listxattr(struct dentry *dentry, char *buff, size_t size);
-#endif
+	yaffs_fill_inode_from_obj(inode, obj);
 
-static int yaffs_write_begin(struct file *filp, struct address_space *mapping,
-			     loff_t pos, unsigned len, unsigned flags,
-			     struct page **pagep, void **fsdata);
-static int yaffs_write_end(struct file *filp, struct address_space *mapping,
-			   loff_t pos, unsigned len, unsigned copied,
-			   struct page *pg, void *fsdadata);
+	yaffs_gross_unlock(dev);
 
-static int yaffs_readlink(struct dentry *dentry, char __user * buffer,
-			  int buflen);
-void yaffs_put_link(struct dentry *dentry, struct nameidata *nd, void *alias);
-static void *yaffs_follow_link(struct dentry *dentry, struct nameidata *nd);
+	unlock_new_inode(inode);
+	return inode;
+}
 
-static void yaffs_touch_super(struct yaffs_dev *dev);
+struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev,
+			      struct yaffs_obj *obj)
+{
+	struct inode *inode;
 
-static int yaffs_vfs_setattr(struct inode *, struct iattr *);
+	if (!sb) {
+		T(YAFFS_TRACE_OS,
+		  (TSTR("yaffs_get_inode for NULL super_block!!\n")));
+		return NULL;
 
-static struct address_space_operations yaffs_file_address_operations = {
-	.readpage = yaffs_readpage,
-	.writepage = yaffs_writepage,
-	.write_begin = yaffs_write_begin,
-	.write_end = yaffs_write_end,
-};
+	}
 
-static const struct file_operations yaffs_file_operations = {
-	.read = do_sync_read,
-	.write = do_sync_write,
-	.aio_read = generic_file_aio_read,
-	.aio_write = generic_file_aio_write,
-	.mmap = generic_file_mmap,
-	.flush = yaffs_file_flush,
-	.fsync = yaffs_sync_object,
-	.splice_read = generic_file_splice_read,
-	.splice_write = generic_file_splice_write,
-	.llseek = generic_file_llseek,
-};
+	if (!obj) {
+		T(YAFFS_TRACE_OS,
+		  (TSTR("yaffs_get_inode for NULL object!!\n")));
+		return NULL;
 
-static const struct inode_operations yaffs_file_inode_operations = {
-	.setattr = yaffs_setattr,
-#ifdef CONFIG_YAFFS_XATTR
-	.setxattr = yaffs_setxattr,
-	.getxattr = yaffs_getxattr,
-	.listxattr = yaffs_listxattr,
-	.removexattr = yaffs_removexattr,
-#endif
-};
+	}
 
-static const struct inode_operations yaffs_symlink_inode_operations = {
-	.readlink = yaffs_readlink,
-	.follow_link = yaffs_follow_link,
-	.put_link = yaffs_put_link,
-	.setattr = yaffs_setattr,
-#ifdef CONFIG_YAFFS_XATTR
-	.setxattr = yaffs_setxattr,
-	.getxattr = yaffs_getxattr,
-	.listxattr = yaffs_listxattr,
-	.removexattr = yaffs_removexattr,
-#endif
-};
+	T(YAFFS_TRACE_OS,
+	  (TSTR("yaffs_get_inode for object %d\n"), obj->obj_id));
 
-static const struct inode_operations yaffs_dir_inode_operations = {
-	.create = yaffs_create,
-	.lookup = yaffs_lookup,
-	.link = yaffs_link,
-	.unlink = yaffs_unlink,
-	.symlink = yaffs_symlink,
-	.mkdir = yaffs_mkdir,
-	.rmdir = yaffs_unlink,
-	.mknod = yaffs_mknod,
-	.rename = yaffs_rename,
-	.setattr = yaffs_setattr,
-#ifdef CONFIG_YAFFS_XATTR
-	.setxattr = yaffs_setxattr,
-	.getxattr = yaffs_getxattr,
-	.listxattr = yaffs_listxattr,
-	.removexattr = yaffs_removexattr,
-#endif
-};
+	inode = yaffs_iget(sb, obj->obj_id);
+	if (IS_ERR(inode))
+		return NULL;
 
-static const struct file_operations yaffs_dir_operations = {
-	.read = generic_read_dir,
-	.readdir = yaffs_readdir,
-	.fsync = yaffs_sync_object,
-	.llseek = generic_file_llseek,
-};
+	/* NB Side effect: iget calls back to yaffs_read_inode(). */
+	/* iget also increments the inode's i_count */
+	/* NB You can't be holding gross_lock or deadlock will happen! */
 
-static const struct super_operations yaffs_super_ops = {
-	.statfs = yaffs_statfs,
-#ifdef YAFFS_HAS_PUT_INODE
-	.put_inode = yaffs_put_inode,
-#endif
-	.put_super = yaffs_put_super,
-	.evict_inode = yaffs_evict_inode,
-	.sync_fs = yaffs_sync_fs,
-	.write_super = yaffs_write_super,
-};
+	return inode;
+}
 
-static int yaffs_vfs_setattr(struct inode *inode, struct iattr *attr)
+static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
+		       dev_t rdev)
 {
-	setattr_copy(inode, attr);
-	return 0;
+	struct inode *inode;
+
+	struct yaffs_obj *obj = NULL;
+	struct yaffs_dev *dev;
+
+	struct yaffs_obj *parent = yaffs_inode_to_obj(dir);
+
+	int error = -ENOSPC;
+	uid_t uid = current->cred->fsuid;
+	gid_t gid =
+	    (dir->i_mode & S_ISGID) ? dir->i_gid : current->cred->fsgid;
+
+	if ((dir->i_mode & S_ISGID) && S_ISDIR(mode))
+		mode |= S_ISGID;
+
+	if (parent) {
+		T(YAFFS_TRACE_OS,
+		  (TSTR("yaffs_mknod: parent object %d type %d\n"),
+		   parent->obj_id, parent->variant_type));
+	} else {
+		T(YAFFS_TRACE_OS,
+		  (TSTR("yaffs_mknod: could not get parent object\n")));
+		return -EPERM;
+	}
+
+	T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making oject for %s, "
+				"mode %x dev %x\n"),
+			   dentry->d_name.name, mode, rdev));
+
+	dev = parent->my_dev;
+
+	yaffs_gross_lock(dev);
+
+	switch (mode & S_IFMT) {
+	default:
+		/* Special (socket, fifo, device...) */
+		T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making special\n")));
+		obj =
+		    yaffs_create_special(parent, dentry->d_name.name, mode, uid,
+					 gid, old_encode_dev(rdev));
+		break;
+	case S_IFREG:		/* file          */
+		T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making file\n")));
+		obj = yaffs_create_file(parent, dentry->d_name.name, mode, uid,
+					gid);
+		break;
+	case S_IFDIR:		/* directory */
+		T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making directory\n")));
+		obj = yaffs_create_dir(parent, dentry->d_name.name, mode,
+				       uid, gid);
+		break;
+	case S_IFLNK:		/* symlink */
+		T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making symlink\n")));
+		obj = NULL;	/* Do we ever get here? */
+		break;
+	}
+
+	/* Can not call yaffs_get_inode() with gross lock held */
+	yaffs_gross_unlock(dev);
+
+	if (obj) {
+		inode = yaffs_get_inode(dir->i_sb, mode, rdev, obj);
+		d_instantiate(dentry, inode);
+		update_dir_time(dir);
+		T(YAFFS_TRACE_OS,
+		  (TSTR("yaffs_mknod created object %d count = %d\n"),
+		   obj->obj_id, atomic_read(&inode->i_count)));
+		error = 0;
+		yaffs_fill_inode_from_obj(dir, parent);
+	} else {
+		T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod failed making object\n")));
+		error = -ENOMEM;
+	}
+
+	return error;
 }
 
-static int yaffs_vfs_setsize(struct inode *inode, loff_t newsize)
+static int yaffs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
 {
-	truncate_setsize(inode, newsize);
-	return 0;
+	int ret_val;
+	T(YAFFS_TRACE_OS, (TSTR("yaffs_mkdir\n")));
+	ret_val = yaffs_mknod(dir, dentry, mode | S_IFDIR, 0);
+	return ret_val;
 }
 
-static unsigned yaffs_gc_control_callback(struct yaffs_dev *dev)
+static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode,
+			struct nameidata *n)
 {
-	return yaffs_gc_control;
+	T(YAFFS_TRACE_OS, (TSTR("yaffs_create\n")));
+	return yaffs_mknod(dir, dentry, mode | S_IFREG, 0);
 }
 
-static void yaffs_gross_lock(struct yaffs_dev *dev)
+static int yaffs_link(struct dentry *old_dentry, struct inode *dir,
+		      struct dentry *dentry)
 {
-	T(YAFFS_TRACE_LOCK, (TSTR("yaffs locking %p\n"), current));
-	mutex_lock(&(yaffs_dev_to_lc(dev)->gross_lock));
-	T(YAFFS_TRACE_LOCK, (TSTR("yaffs locked %p\n"), current));
+	struct inode *inode = old_dentry->d_inode;
+	struct yaffs_obj *obj = NULL;
+	struct yaffs_obj *link = NULL;
+	struct yaffs_dev *dev;
+
+	T(YAFFS_TRACE_OS, (TSTR("yaffs_link\n")));
+
+	obj = yaffs_inode_to_obj(inode);
+	dev = obj->my_dev;
+
+	yaffs_gross_lock(dev);
+
+	if (!S_ISDIR(inode->i_mode))	/* Don't link directories */
+		link =
+		    yaffs_link_obj(yaffs_inode_to_obj(dir), dentry->d_name.name,
+				   obj);
+
+	if (link) {
+		old_dentry->d_inode->i_nlink = yaffs_get_obj_link_count(obj);
+		d_instantiate(dentry, old_dentry->d_inode);
+		atomic_inc(&old_dentry->d_inode->i_count);
+		T(YAFFS_TRACE_OS,
+		  (TSTR("yaffs_link link count %d i_count %d\n"),
+		   old_dentry->d_inode->i_nlink,
+		   atomic_read(&old_dentry->d_inode->i_count)));
+	}
+
+	yaffs_gross_unlock(dev);
+
+	if (link) {
+		update_dir_time(dir);
+		return 0;
+	}
+
+	return -EPERM;
 }
 
-static void yaffs_gross_unlock(struct yaffs_dev *dev)
+static int yaffs_symlink(struct inode *dir, struct dentry *dentry,
+			 const char *symname)
 {
-	T(YAFFS_TRACE_LOCK, (TSTR("yaffs unlocking %p\n"), current));
-	mutex_unlock(&(yaffs_dev_to_lc(dev)->gross_lock));
+	struct yaffs_obj *obj;
+	struct yaffs_dev *dev;
+	uid_t uid = current->cred->fsuid;
+	gid_t gid =
+	    (dir->i_mode & S_ISGID) ? dir->i_gid : current->cred->fsgid;
+
+	T(YAFFS_TRACE_OS, (TSTR("yaffs_symlink\n")));
+
+	dev = yaffs_inode_to_obj(dir)->my_dev;
+	yaffs_gross_lock(dev);
+	obj = yaffs_create_symlink(yaffs_inode_to_obj(dir), dentry->d_name.name,
+				   S_IFLNK | S_IRWXUGO, uid, gid, symname);
+	yaffs_gross_unlock(dev);
+
+	if (obj) {
+		struct inode *inode;
+
+		inode = yaffs_get_inode(dir->i_sb, obj->yst_mode, 0, obj);
+		d_instantiate(dentry, inode);
+		update_dir_time(dir);
+		T(YAFFS_TRACE_OS, (TSTR("symlink created OK\n")));
+		return 0;
+	} else {
+		T(YAFFS_TRACE_OS, (TSTR("symlink not created\n")));
+	}
+
+	return -ENOMEM;
 }
 
-/* ExportFS support */
-static struct inode *yaffs2_nfs_get_inode(struct super_block *sb, uint64_t ino,
-					  uint32_t generation)
+static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry,
+				   struct nameidata *n)
 {
-	return Y_IGET(sb, ino);
+	struct yaffs_obj *obj;
+	struct inode *inode = NULL;
+
+	struct yaffs_dev *dev = yaffs_inode_to_obj(dir)->my_dev;
+
+	if (current != yaffs_dev_to_lc(dev)->readdir_process)
+		yaffs_gross_lock(dev);
+
+	T(YAFFS_TRACE_OS,
+	  (TSTR("yaffs_lookup for %d:%s\n"),
+	   yaffs_inode_to_obj(dir)->obj_id, dentry->d_name.name));
+
+	obj = yaffs_find_by_name(yaffs_inode_to_obj(dir), dentry->d_name.name);
+
+	obj = yaffs_get_equivalent_obj(obj);	/* in case it was a hardlink */
+
+	/* Can't hold gross lock when calling yaffs_get_inode() */
+	if (current != yaffs_dev_to_lc(dev)->readdir_process)
+		yaffs_gross_unlock(dev);
+
+	if (obj) {
+		T(YAFFS_TRACE_OS,
+		  (TSTR("yaffs_lookup found %d\n"), obj->obj_id));
+
+		inode = yaffs_get_inode(dir->i_sb, obj->yst_mode, 0, obj);
+
+		if (inode) {
+			T(YAFFS_TRACE_OS, (TSTR("yaffs_loookup dentry \n")));
+			d_add(dentry, inode);
+			/* return dentry; */
+			return NULL;
+		}
+
+	} else {
+		T(YAFFS_TRACE_OS, (TSTR("yaffs_lookup not found\n")));
+
+	}
+
+	d_add(dentry, inode);
+
+	return NULL;
 }
 
-static struct dentry *yaffs2_fh_to_dentry(struct super_block *sb,
-					  struct fid *fid, int fh_len,
-					  int fh_type)
+static int yaffs_unlink(struct inode *dir, struct dentry *dentry)
 {
-	return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
-				    yaffs2_nfs_get_inode);
+	int ret_val;
+
+	struct yaffs_dev *dev;
+	struct yaffs_obj *obj;
+
+	T(YAFFS_TRACE_OS,
+	  (TSTR("yaffs_unlink %d:%s\n"),
+	   (int)(dir->i_ino), dentry->d_name.name));
+	obj = yaffs_inode_to_obj(dir);
+	dev = obj->my_dev;
+
+	yaffs_gross_lock(dev);
+
+	ret_val = yaffs_unlinker(obj, dentry->d_name.name);
+
+	if (ret_val == YAFFS_OK) {
+		dentry->d_inode->i_nlink--;
+		dir->i_version++;
+		yaffs_gross_unlock(dev);
+		mark_inode_dirty(dentry->d_inode);
+		update_dir_time(dir);
+		return 0;
+	}
+	yaffs_gross_unlock(dev);
+	return -ENOTEMPTY;
 }
 
-static struct dentry *yaffs2_fh_to_parent(struct super_block *sb,
-					  struct fid *fid, int fh_len,
-					  int fh_type)
+static int yaffs_sync_object(struct file *file, int datasync)
 {
-	return generic_fh_to_parent(sb, fid, fh_len, fh_type,
-				    yaffs2_nfs_get_inode);
-}
 
-struct dentry *yaffs2_get_parent(struct dentry *dentry)
+	struct yaffs_obj *obj;
+	struct yaffs_dev *dev;
+	struct dentry *dentry = file->f_path.dentry;
+
+	obj = yaffs_dentry_to_obj(dentry);
+
+	dev = obj->my_dev;
+
+	T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC, (TSTR("yaffs_sync_object\n")));
+	yaffs_gross_lock(dev);
+	yaffs_flush_file(obj, 1, datasync);
+	yaffs_gross_unlock(dev);
+	return 0;
+}
+/*
+ * The VFS layer already does all the dentry stuff for rename.
+ *
+ * NB: POSIX says you can rename an object over an old object of the same name
+ */
+static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry,
+			struct inode *new_dir, struct dentry *new_dentry)
 {
+	struct yaffs_dev *dev;
+	int ret_val = YAFFS_FAIL;
+	struct yaffs_obj *target;
 
-	struct super_block *sb = dentry->d_inode->i_sb;
-	struct dentry *parent = ERR_PTR(-ENOENT);
-	struct inode *inode;
-	unsigned long parent_ino;
-	struct yaffs_obj *d_obj;
-	struct yaffs_obj *parent_obj;
+	T(YAFFS_TRACE_OS, (TSTR("yaffs_rename\n")));
+	dev = yaffs_inode_to_obj(old_dir)->my_dev;
 
-	d_obj = yaffs_inode_to_obj(dentry->d_inode);
+	yaffs_gross_lock(dev);
 
-	if (d_obj) {
-		parent_obj = d_obj->parent;
-		if (parent_obj) {
-			parent_ino = yaffs_get_obj_inode(parent_obj);
-			inode = Y_IGET(sb, parent_ino);
+	/* Check if the target is an existing directory that is not empty. */
+	target = yaffs_find_by_name(yaffs_inode_to_obj(new_dir),
+				    new_dentry->d_name.name);
 
-			if (IS_ERR(inode)) {
-				parent = ERR_CAST(inode);
-			} else {
-				parent = d_obtain_alias(inode);
-				if (!IS_ERR(parent)) {
-					parent = ERR_PTR(-ENOMEM);
-					iput(inode);
-				}
+	if (target && target->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY &&
+	    !list_empty(&target->variant.dir_variant.children)) {
+
+		T(YAFFS_TRACE_OS, (TSTR("target is non-empty dir\n")));
+
+		ret_val = YAFFS_FAIL;
+	} else {
+		/* Now does unlinking internally using shadowing mechanism */
+		T(YAFFS_TRACE_OS, (TSTR("calling yaffs_rename_obj\n")));
+
+		ret_val = yaffs_rename_obj(yaffs_inode_to_obj(old_dir),
+					   old_dentry->d_name.name,
+					   yaffs_inode_to_obj(new_dir),
+					   new_dentry->d_name.name);
+	}
+	yaffs_gross_unlock(dev);
+
+	if (ret_val == YAFFS_OK) {
+		if (target) {
+			new_dentry->d_inode->i_nlink--;
+			mark_inode_dirty(new_dentry->d_inode);
+		}
+
+		update_dir_time(old_dir);
+		if (old_dir != new_dir)
+			update_dir_time(new_dir);
+		return 0;
+	} else {
+		return -ENOTEMPTY;
+	}
+}
+
+static int yaffs_setattr(struct dentry *dentry, struct iattr *attr)
+{
+	struct inode *inode = dentry->d_inode;
+	int error = 0;
+	struct yaffs_dev *dev;
+
+	T(YAFFS_TRACE_OS,
+	  (TSTR("yaffs_setattr of object %d\n"),
+	   yaffs_inode_to_obj(inode)->obj_id));
+
+	/* Fail if a requested resize >= 2GB */
+	if (attr->ia_valid & ATTR_SIZE && (attr->ia_size >> 31))
+		error = -EINVAL;
+
+	if (error == 0)
+		error = inode_change_ok(inode, attr);
+	if (error == 0) {
+		int result;
+		if (!error) {
+			setattr_copy(inode, attr);
+			T(YAFFS_TRACE_OS, (TSTR("inode_setattr called\n")));
+			if (attr->ia_valid & ATTR_SIZE) {
+				truncate_setsize(inode, attr->ia_size);
+				inode->i_blocks = (inode->i_size + 511) >> 9;
 			}
 		}
+		dev = yaffs_inode_to_obj(inode)->my_dev;
+		if (attr->ia_valid & ATTR_SIZE) {
+			T(YAFFS_TRACE_OS, (TSTR("resize to %d(%x)\n"),
+					   (int)(attr->ia_size),
+					   (int)(attr->ia_size)));
+		}
+		yaffs_gross_lock(dev);
+		result = yaffs_set_attribs(yaffs_inode_to_obj(inode), attr);
+		if (result == YAFFS_OK) {
+			error = 0;
+		} else {
+			error = -EPERM;
+		}
+		yaffs_gross_unlock(dev);
+
 	}
 
-	return parent;
+	T(YAFFS_TRACE_OS, (TSTR("yaffs_setattr done returning %d\n"), error));
+
+	return error;
 }
 
-/* Just declare a zero structure as a NULL value implies
- * using the default functions of exportfs.
- */
+#ifdef CONFIG_YAFFS_XATTR
+static int yaffs_setxattr(struct dentry *dentry, const char *name,
+		   const void *value, size_t size, int flags)
+{
+	struct inode *inode = dentry->d_inode;
+	int error = 0;
+	struct yaffs_dev *dev;
+	struct yaffs_obj *obj = yaffs_inode_to_obj(inode);
 
-static struct export_operations yaffs_export_ops = {
-	.fh_to_dentry = yaffs2_fh_to_dentry,
-	.fh_to_parent = yaffs2_fh_to_parent,
-	.get_parent = yaffs2_get_parent,
-};
+	T(YAFFS_TRACE_OS, (TSTR("yaffs_setxattr of object %d\n"), obj->obj_id));
+
+	if (error == 0) {
+		int result;
+		dev = obj->my_dev;
+		yaffs_gross_lock(dev);
+		result = yaffs_set_xattrib(obj, name, value, size, flags);
+		if (result == YAFFS_OK)
+			error = 0;
+		else if (result < 0)
+			error = result;
+		yaffs_gross_unlock(dev);
+
+	}
+	T(YAFFS_TRACE_OS, (TSTR("yaffs_setxattr done returning %d\n"), error));
+
+	return error;
+}
+
+static ssize_t yaffs_getxattr(struct dentry * dentry, const char *name, void *buff,
+		       size_t size)
+{
+	struct inode *inode = dentry->d_inode;
+	int error = 0;
+	struct yaffs_dev *dev;
+	struct yaffs_obj *obj = yaffs_inode_to_obj(inode);
+
+	T(YAFFS_TRACE_OS,
+	  (TSTR("yaffs_getxattr \"%s\" from object %d\n"), name, obj->obj_id));
+
+	if (error == 0) {
+		dev = obj->my_dev;
+		yaffs_gross_lock(dev);
+		error = yaffs_get_xattrib(obj, name, buff, size);
+		yaffs_gross_unlock(dev);
+
+	}
+	T(YAFFS_TRACE_OS, (TSTR("yaffs_getxattr done returning %d\n"), error));
+
+	return error;
+}
+
+static int yaffs_removexattr(struct dentry *dentry, const char *name)
+{
+	struct inode *inode = dentry->d_inode;
+	int error = 0;
+	struct yaffs_dev *dev;
+	struct yaffs_obj *obj = yaffs_inode_to_obj(inode);
+
+	T(YAFFS_TRACE_OS,
+	  (TSTR("yaffs_removexattr of object %d\n"), obj->obj_id));
+
+	if (error == 0) {
+		int result;
+		dev = obj->my_dev;
+		yaffs_gross_lock(dev);
+		result = yaffs_remove_xattrib(obj, name);
+		if (result == YAFFS_OK)
+			error = 0;
+		else if (result < 0)
+			error = result;
+		yaffs_gross_unlock(dev);
+
+	}
+	T(YAFFS_TRACE_OS,
+	  (TSTR("yaffs_removexattr done returning %d\n"), error));
+
+	return error;
+}
+
+static ssize_t yaffs_listxattr(struct dentry * dentry, char *buff, size_t size)
+{
+	struct inode *inode = dentry->d_inode;
+	int error = 0;
+	struct yaffs_dev *dev;
+	struct yaffs_obj *obj = yaffs_inode_to_obj(inode);
+
+	T(YAFFS_TRACE_OS,
+	  (TSTR("yaffs_listxattr of object %d\n"), obj->obj_id));
 
+	if (error == 0) {
+		dev = obj->my_dev;
+		yaffs_gross_lock(dev);
+		error = yaffs_list_xattrib(obj, buff, size);
+		yaffs_gross_unlock(dev);
+
+	}
+	T(YAFFS_TRACE_OS, (TSTR("yaffs_listxattr done returning %d\n"), error));
+
+	return error;
+}
+
+#endif
+
+static const struct inode_operations yaffs_dir_inode_operations = {
+	.create = yaffs_create,
+	.lookup = yaffs_lookup,
+	.link = yaffs_link,
+	.unlink = yaffs_unlink,
+	.symlink = yaffs_symlink,
+	.mkdir = yaffs_mkdir,
+	.rmdir = yaffs_unlink,
+	.mknod = yaffs_mknod,
+	.rename = yaffs_rename,
+	.setattr = yaffs_setattr,
+#ifdef CONFIG_YAFFS_XATTR
+	.setxattr = yaffs_setxattr,
+	.getxattr = yaffs_getxattr,
+	.listxattr = yaffs_listxattr,
+	.removexattr = yaffs_removexattr,
+#endif
+};
 /*-----------------------------------------------------------------*/
 /* Directory search context allows us to unlock access to yaffs during
  * filldir without causing problems with the directory being modified.
@@ -399,7 +718,7 @@ static struct yaffs_search_context *yaffs_new_search(struct yaffs_obj *dir)
 {
 	struct yaffs_dev *dev = dir->my_dev;
 	struct yaffs_search_context *sc =
-	    YMALLOC(sizeof(struct yaffs_search_context));
+	    kmalloc(sizeof(struct yaffs_search_context), GFP_NOFS);
 	if (sc) {
 		sc->dir_obj = dir;
 		sc->dev = dev;
@@ -422,7 +741,7 @@ static void yaffs_search_end(struct yaffs_search_context *sc)
 {
 	if (sc) {
 		list_del(&sc->others);
-		YFREE(sc);
+		kfree(sc);
 	}
 }
 
@@ -477,6 +796,222 @@ static void yaffs_remove_obj_callback(struct yaffs_obj *obj)
 
 }
 
+static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir)
+{
+	struct yaffs_obj *obj;
+	struct yaffs_dev *dev;
+	struct yaffs_search_context *sc;
+	struct inode *inode = f->f_dentry->d_inode;
+	unsigned long offset, curoffs;
+	struct yaffs_obj *l;
+	int ret_val = 0;
+
+	char name[YAFFS_MAX_NAME_LENGTH + 1];
+
+	obj = yaffs_dentry_to_obj(f->f_dentry);
+	dev = obj->my_dev;
+
+	yaffs_gross_lock(dev);
+
+	yaffs_dev_to_lc(dev)->readdir_process = current;
+
+	offset = f->f_pos;
+
+	sc = yaffs_new_search(obj);
+	if (!sc) {
+		ret_val = -ENOMEM;
+		goto out;
+	}
+
+	T(YAFFS_TRACE_OS,
+	  (TSTR("yaffs_readdir: starting at %d\n"), (int)offset));
+
+	if (offset == 0) {
+		T(YAFFS_TRACE_OS,
+		  (TSTR("yaffs_readdir: entry . ino %d \n"),
+		   (int)inode->i_ino));
+		yaffs_gross_unlock(dev);
+		if (filldir(dirent, ".", 1, offset, inode->i_ino, DT_DIR) < 0) {
+			yaffs_gross_lock(dev);
+			goto out;
+		}
+		yaffs_gross_lock(dev);
+		offset++;
+		f->f_pos++;
+	}
+	if (offset == 1) {
+		T(YAFFS_TRACE_OS,
+		  (TSTR("yaffs_readdir: entry .. ino %d \n"),
+		   (int)f->f_dentry->d_parent->d_inode->i_ino));
+		yaffs_gross_unlock(dev);
+		if (filldir(dirent, "..", 2, offset,
+			    f->f_dentry->d_parent->d_inode->i_ino,
+			    DT_DIR) < 0) {
+			yaffs_gross_lock(dev);
+			goto out;
+		}
+		yaffs_gross_lock(dev);
+		offset++;
+		f->f_pos++;
+	}
+
+	curoffs = 1;
+
+	/* If the directory has changed since the open or last call to
+	   readdir, rewind to after the 2 canned entries. */
+	if (f->f_version != inode->i_version) {
+		offset = 2;
+		f->f_pos = offset;
+		f->f_version = inode->i_version;
+	}
+
+	while (sc->next_return) {
+		curoffs++;
+		l = sc->next_return;
+		if (curoffs >= offset) {
+			int this_inode = yaffs_get_obj_inode(l);
+			int this_type = yaffs_get_obj_type(l);
+
+			yaffs_get_obj_name(l, name, YAFFS_MAX_NAME_LENGTH + 1);
+			T(YAFFS_TRACE_OS,
+			  (TSTR("yaffs_readdir: %s inode %d\n"),
+			   name, yaffs_get_obj_inode(l)));
+
+			yaffs_gross_unlock(dev);
+
+			if (filldir(dirent,
+				    name,
+				    strlen(name),
+				    offset, this_inode, this_type) < 0) {
+				yaffs_gross_lock(dev);
+				goto out;
+			}
+
+			yaffs_gross_lock(dev);
+
+			offset++;
+			f->f_pos++;
+		}
+		yaffs_search_advance(sc);
+	}
+
+out:
+	yaffs_search_end(sc);
+	yaffs_dev_to_lc(dev)->readdir_process = NULL;
+	yaffs_gross_unlock(dev);
+
+	return ret_val;
+}
+
+static const struct file_operations yaffs_dir_operations = {
+	.read = generic_read_dir,
+	.readdir = yaffs_readdir,
+	.fsync = yaffs_sync_object,
+	.llseek = generic_file_llseek,
+};
+
+
+
+static int yaffs_file_flush(struct file *file, fl_owner_t id)
+{
+	struct yaffs_obj *obj = yaffs_dentry_to_obj(file->f_dentry);
+
+	struct yaffs_dev *dev = obj->my_dev;
+
+	T(YAFFS_TRACE_OS,
+	  (TSTR("yaffs_file_flush object %d (%s)\n"), obj->obj_id,
+	   obj->dirty ? "dirty" : "clean"));
+
+	yaffs_gross_lock(dev);
+
+	yaffs_flush_file(obj, 1, 0);
+
+	yaffs_gross_unlock(dev);
+
+	return 0;
+}
+
+static const struct file_operations yaffs_file_operations = {
+	.read = do_sync_read,
+	.write = do_sync_write,
+	.aio_read = generic_file_aio_read,
+	.aio_write = generic_file_aio_write,
+	.mmap = generic_file_mmap,
+	.flush = yaffs_file_flush,
+	.fsync = yaffs_sync_object,
+	.splice_read = generic_file_splice_read,
+	.splice_write = generic_file_splice_write,
+	.llseek = generic_file_llseek,
+};
+
+
+/* ExportFS support */
+static struct inode *yaffs2_nfs_get_inode(struct super_block *sb, uint64_t ino,
+					  uint32_t generation)
+{
+	return yaffs_iget(sb, ino);
+}
+
+static struct dentry *yaffs2_fh_to_dentry(struct super_block *sb,
+					  struct fid *fid, int fh_len,
+					  int fh_type)
+{
+	return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
+				    yaffs2_nfs_get_inode);
+}
+
+static struct dentry *yaffs2_fh_to_parent(struct super_block *sb,
+					  struct fid *fid, int fh_len,
+					  int fh_type)
+{
+	return generic_fh_to_parent(sb, fid, fh_len, fh_type,
+				    yaffs2_nfs_get_inode);
+}
+
+struct dentry *yaffs2_get_parent(struct dentry *dentry)
+{
+
+	struct super_block *sb = dentry->d_inode->i_sb;
+	struct dentry *parent = ERR_PTR(-ENOENT);
+	struct inode *inode;
+	unsigned long parent_ino;
+	struct yaffs_obj *d_obj;
+	struct yaffs_obj *parent_obj;
+
+	d_obj = yaffs_inode_to_obj(dentry->d_inode);
+
+	if (d_obj) {
+		parent_obj = d_obj->parent;
+		if (parent_obj) {
+			parent_ino = yaffs_get_obj_inode(parent_obj);
+			inode = yaffs_iget(sb, parent_ino);
+
+			if (IS_ERR(inode)) {
+				parent = ERR_CAST(inode);
+			} else {
+				parent = d_obtain_alias(inode);
+				if (!IS_ERR(parent)) {
+					parent = ERR_PTR(-ENOMEM);
+					iput(inode);
+				}
+			}
+		}
+	}
+
+	return parent;
+}
+
+/* Just declare a zero structure as a NULL value implies
+ * using the default functions of exportfs.
+ */
+
+static struct export_operations yaffs_export_ops = {
+	.fh_to_dentry = yaffs2_fh_to_dentry,
+	.fh_to_parent = yaffs2_fh_to_parent,
+	.get_parent = yaffs2_get_parent,
+};
+
+
 /*-----------------------------------------------------------------*/
 
 static int yaffs_readlink(struct dentry *dentry, char __user * buffer,
@@ -528,72 +1063,6 @@ void yaffs_put_link(struct dentry *dentry, struct nameidata *nd, void *alias)
 	kfree(alias);
 }
 
-struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev,
-			      struct yaffs_obj *obj);
-
-/*
- * Lookup is used to find objects in the fs
- */
-
-static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry,
-				   struct nameidata *n)
-{
-	struct yaffs_obj *obj;
-	struct inode *inode = NULL;	/* NCB 2.5/2.6 needs NULL here */
-
-	struct yaffs_dev *dev = yaffs_inode_to_obj(dir)->my_dev;
-
-	if (current != yaffs_dev_to_lc(dev)->readdir_process)
-		yaffs_gross_lock(dev);
-
-	T(YAFFS_TRACE_OS,
-	  (TSTR("yaffs_lookup for %d:%s\n"),
-	   yaffs_inode_to_obj(dir)->obj_id, dentry->d_name.name));
-
-	obj = yaffs_find_by_name(yaffs_inode_to_obj(dir), dentry->d_name.name);
-
-	obj = yaffs_get_equivalent_obj(obj);	/* in case it was a hardlink */
-
-	/* Can't hold gross lock when calling yaffs_get_inode() */
-	if (current != yaffs_dev_to_lc(dev)->readdir_process)
-		yaffs_gross_unlock(dev);
-
-	if (obj) {
-		T(YAFFS_TRACE_OS,
-		  (TSTR("yaffs_lookup found %d\n"), obj->obj_id));
-
-		inode = yaffs_get_inode(dir->i_sb, obj->yst_mode, 0, obj);
-
-		if (inode) {
-			T(YAFFS_TRACE_OS, (TSTR("yaffs_loookup dentry \n")));
-			d_add(dentry, inode);
-			/* return dentry; */
-			return NULL;
-		}
-
-	} else {
-		T(YAFFS_TRACE_OS, (TSTR("yaffs_lookup not found\n")));
-
-	}
-
-	d_add(dentry, inode);
-
-	return NULL;
-}
-
-#ifdef YAFFS_HAS_PUT_INODE
-
-/* For now put inode is just for debugging
- * Put inode is called when the inode **structure** is put.
- */
-static void yaffs_put_inode(struct inode *inode)
-{
-	T(YAFFS_TRACE_OS,
-	  (TSTR("yaffs_put_inode: ino %d, count %d\n"), (int)inode->i_ino,
-	   atomic_read(&inode->i_count)));
-
-}
-#endif
 
 static void yaffs_unstitch_obj(struct inode *inode, struct yaffs_obj *obj)
 {
@@ -647,23 +1116,13 @@ static void yaffs_evict_inode(struct inode *inode)
 
 }
 
-static int yaffs_file_flush(struct file *file, fl_owner_t id)
+static void yaffs_touch_super(struct yaffs_dev *dev)
 {
-	struct yaffs_obj *obj = yaffs_dentry_to_obj(file->f_dentry);
-
-	struct yaffs_dev *dev = obj->my_dev;
-
-	T(YAFFS_TRACE_OS,
-	  (TSTR("yaffs_file_flush object %d (%s)\n"), obj->obj_id,
-	   obj->dirty ? "dirty" : "clean"));
-
-	yaffs_gross_lock(dev);
-
-	yaffs_flush_file(obj, 1, 0);
-
-	yaffs_gross_unlock(dev);
+	struct super_block *sb = yaffs_dev_to_lc(dev)->super;
 
-	return 0;
+	T(YAFFS_TRACE_OS, (TSTR("yaffs_touch_super() sb = %p\n"), sb));
+	if (sb)
+		sb->s_dirt = 1;
 }
 
 static int yaffs_readpage_nolock(struct file *f, struct page *pg)
@@ -815,6 +1274,47 @@ static int yaffs_writepage(struct page *page, struct writeback_control *wbc)
 	return (n_written == n_bytes) ? 0 : -ENOSPC;
 }
 
+/* Space holding and freeing is done to ensure we have space available for 
+ * write_begin/end.
+ * For now we just assume few parallel writes and check against a small
+ * number.
+ * Todo: need to do this with a counter to handle parallel reads better.
+ */
+
+static ssize_t yaffs_hold_space(struct file *f)
+{
+	struct yaffs_obj *obj;
+	struct yaffs_dev *dev;
+
+	int n_free_chunks;
+
+	obj = yaffs_dentry_to_obj(f->f_dentry);
+
+	dev = obj->my_dev;
+
+	yaffs_gross_lock(dev);
+
+	n_free_chunks = yaffs_get_n_free_chunks(dev);
+
+	yaffs_gross_unlock(dev);
+
+	return (n_free_chunks > 20) ? 1 : 0;
+}
+
+static void yaffs_release_space(struct file *f)
+{
+	struct yaffs_obj *obj;
+	struct yaffs_dev *dev;
+
+	obj = yaffs_dentry_to_obj(f->f_dentry);
+
+	dev = obj->my_dev;
+
+	yaffs_gross_lock(dev);
+
+	yaffs_gross_unlock(dev);
+}
+
 static int yaffs_write_begin(struct file *filp, struct address_space *mapping,
 			     loff_t pos, unsigned len, unsigned flags,
 			     struct page **pagep, void **fsdata)
@@ -870,167 +1370,6 @@ out:
 	return ret;
 }
 
-static int yaffs_write_end(struct file *filp, struct address_space *mapping,
-			   loff_t pos, unsigned len, unsigned copied,
-			   struct page *pg, void *fsdadata)
-{
-	int ret = 0;
-	void *addr, *kva;
-	uint32_t offset_into_page = pos & (PAGE_CACHE_SIZE - 1);
-
-	kva = kmap(pg);
-	addr = kva + offset_into_page;
-
-	T(YAFFS_TRACE_OS,
-	  ("yaffs_write_end addr %p pos %x n_bytes %d\n",
-	   addr, (unsigned)pos, copied));
-
-	ret = yaffs_file_write(filp, addr, copied, &pos);
-
-	if (ret != copied) {
-		T(YAFFS_TRACE_OS,
-		  (TSTR("yaffs_write_end not same size ret %d  copied %d\n"),
-		   ret, copied));
-		SetPageError(pg);
-	} else {
-		/* Nothing */
-	}
-
-	kunmap(pg);
-
-	yaffs_release_space(filp);
-	unlock_page(pg);
-	page_cache_release(pg);
-	return ret;
-}
-
-static void yaffs_fill_inode_from_obj(struct inode *inode,
-				      struct yaffs_obj *obj)
-{
-	if (inode && obj) {
-
-		/* Check mode against the variant type and attempt to repair if broken. */
-		u32 mode = obj->yst_mode;
-		switch (obj->variant_type) {
-		case YAFFS_OBJECT_TYPE_FILE:
-			if (!S_ISREG(mode)) {
-				obj->yst_mode &= ~S_IFMT;
-				obj->yst_mode |= S_IFREG;
-			}
-
-			break;
-		case YAFFS_OBJECT_TYPE_SYMLINK:
-			if (!S_ISLNK(mode)) {
-				obj->yst_mode &= ~S_IFMT;
-				obj->yst_mode |= S_IFLNK;
-			}
-
-			break;
-		case YAFFS_OBJECT_TYPE_DIRECTORY:
-			if (!S_ISDIR(mode)) {
-				obj->yst_mode &= ~S_IFMT;
-				obj->yst_mode |= S_IFDIR;
-			}
-
-			break;
-		case YAFFS_OBJECT_TYPE_UNKNOWN:
-		case YAFFS_OBJECT_TYPE_HARDLINK:
-		case YAFFS_OBJECT_TYPE_SPECIAL:
-		default:
-			/* TODO? */
-			break;
-		}
-
-		inode->i_flags |= S_NOATIME;
-
-		inode->i_ino = obj->obj_id;
-		inode->i_mode = obj->yst_mode;
-		inode->i_uid = obj->yst_uid;
-		inode->i_gid = obj->yst_gid;
-
-		inode->i_rdev = old_decode_dev(obj->yst_rdev);
-
-		inode->i_atime.tv_sec = (time_t) (obj->yst_atime);
-		inode->i_atime.tv_nsec = 0;
-		inode->i_mtime.tv_sec = (time_t) obj->yst_mtime;
-		inode->i_mtime.tv_nsec = 0;
-		inode->i_ctime.tv_sec = (time_t) obj->yst_ctime;
-		inode->i_ctime.tv_nsec = 0;
-		inode->i_size = yaffs_get_obj_length(obj);
-		inode->i_blocks = (inode->i_size + 511) >> 9;
-
-		inode->i_nlink = yaffs_get_obj_link_count(obj);
-
-		T(YAFFS_TRACE_OS,
-		  (TSTR
-		   ("yaffs_fill_inode mode %x uid %d gid %d size %d count %d\n"),
-		   inode->i_mode, inode->i_uid, inode->i_gid,
-		   (int)inode->i_size, atomic_read(&inode->i_count)));
-
-		switch (obj->yst_mode & S_IFMT) {
-		default:	/* fifo, device or socket */
-			init_special_inode(inode, obj->yst_mode,
-					   old_decode_dev(obj->yst_rdev));
-			break;
-		case S_IFREG:	/* file */
-			inode->i_op = &yaffs_file_inode_operations;
-			inode->i_fop = &yaffs_file_operations;
-			inode->i_mapping->a_ops =
-			    &yaffs_file_address_operations;
-			break;
-		case S_IFDIR:	/* directory */
-			inode->i_op = &yaffs_dir_inode_operations;
-			inode->i_fop = &yaffs_dir_operations;
-			break;
-		case S_IFLNK:	/* symlink */
-			inode->i_op = &yaffs_symlink_inode_operations;
-			break;
-		}
-
-		yaffs_inode_to_obj_lv(inode) = obj;
-
-		obj->my_inode = inode;
-
-	} else {
-		T(YAFFS_TRACE_OS,
-		  (TSTR("yaffs_fill_inode invalid parameters\n")));
-	}
-
-}
-
-struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev,
-			      struct yaffs_obj *obj)
-{
-	struct inode *inode;
-
-	if (!sb) {
-		T(YAFFS_TRACE_OS,
-		  (TSTR("yaffs_get_inode for NULL super_block!!\n")));
-		return NULL;
-
-	}
-
-	if (!obj) {
-		T(YAFFS_TRACE_OS,
-		  (TSTR("yaffs_get_inode for NULL object!!\n")));
-		return NULL;
-
-	}
-
-	T(YAFFS_TRACE_OS,
-	  (TSTR("yaffs_get_inode for object %d\n"), obj->obj_id));
-
-	inode = Y_IGET(sb, obj->obj_id);
-	if (IS_ERR(inode))
-		return NULL;
-
-	/* NB Side effect: iget calls back to yaffs_read_inode(). */
-	/* iget also increments the inode's i_count */
-	/* NB You can't be holding gross_lock or deadlock will happen! */
-
-	return inode;
-}
-
 static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n,
 				loff_t * pos)
 {
@@ -1086,578 +1425,40 @@ static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n,
 	return (n_written == 0) && (n > 0) ? -ENOSPC : n_written;
 }
 
-/* Space holding and freeing is done to ensure we have space available for write_begin/end */
-/* For now we just assume few parallel writes and check against a small number. */
-/* Todo: need to do this with a counter to handle parallel reads better */
-
-static ssize_t yaffs_hold_space(struct file *f)
-{
-	struct yaffs_obj *obj;
-	struct yaffs_dev *dev;
-
-	int n_free_chunks;
-
-	obj = yaffs_dentry_to_obj(f->f_dentry);
-
-	dev = obj->my_dev;
-
-	yaffs_gross_lock(dev);
-
-	n_free_chunks = yaffs_get_n_free_chunks(dev);
-
-	yaffs_gross_unlock(dev);
-
-	return (n_free_chunks > 20) ? 1 : 0;
-}
-
-static void yaffs_release_space(struct file *f)
-{
-	struct yaffs_obj *obj;
-	struct yaffs_dev *dev;
-
-	obj = yaffs_dentry_to_obj(f->f_dentry);
-
-	dev = obj->my_dev;
-
-	yaffs_gross_lock(dev);
-
-	yaffs_gross_unlock(dev);
-}
-
-static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir)
-{
-	struct yaffs_obj *obj;
-	struct yaffs_dev *dev;
-	struct yaffs_search_context *sc;
-	struct inode *inode = f->f_dentry->d_inode;
-	unsigned long offset, curoffs;
-	struct yaffs_obj *l;
-	int ret_val = 0;
-
-	char name[YAFFS_MAX_NAME_LENGTH + 1];
-
-	obj = yaffs_dentry_to_obj(f->f_dentry);
-	dev = obj->my_dev;
-
-	yaffs_gross_lock(dev);
-
-	yaffs_dev_to_lc(dev)->readdir_process = current;
-
-	offset = f->f_pos;
-
-	sc = yaffs_new_search(obj);
-	if (!sc) {
-		ret_val = -ENOMEM;
-		goto out;
-	}
-
-	T(YAFFS_TRACE_OS,
-	  (TSTR("yaffs_readdir: starting at %d\n"), (int)offset));
-
-	if (offset == 0) {
-		T(YAFFS_TRACE_OS,
-		  (TSTR("yaffs_readdir: entry . ino %d \n"),
-		   (int)inode->i_ino));
-		yaffs_gross_unlock(dev);
-		if (filldir(dirent, ".", 1, offset, inode->i_ino, DT_DIR) < 0) {
-			yaffs_gross_lock(dev);
-			goto out;
-		}
-		yaffs_gross_lock(dev);
-		offset++;
-		f->f_pos++;
-	}
-	if (offset == 1) {
-		T(YAFFS_TRACE_OS,
-		  (TSTR("yaffs_readdir: entry .. ino %d \n"),
-		   (int)f->f_dentry->d_parent->d_inode->i_ino));
-		yaffs_gross_unlock(dev);
-		if (filldir(dirent, "..", 2, offset,
-			    f->f_dentry->d_parent->d_inode->i_ino,
-			    DT_DIR) < 0) {
-			yaffs_gross_lock(dev);
-			goto out;
-		}
-		yaffs_gross_lock(dev);
-		offset++;
-		f->f_pos++;
-	}
-
-	curoffs = 1;
-
-	/* If the directory has changed since the open or last call to
-	   readdir, rewind to after the 2 canned entries. */
-	if (f->f_version != inode->i_version) {
-		offset = 2;
-		f->f_pos = offset;
-		f->f_version = inode->i_version;
-	}
-
-	while (sc->next_return) {
-		curoffs++;
-		l = sc->next_return;
-		if (curoffs >= offset) {
-			int this_inode = yaffs_get_obj_inode(l);
-			int this_type = yaffs_get_obj_type(l);
-
-			yaffs_get_obj_name(l, name, YAFFS_MAX_NAME_LENGTH + 1);
-			T(YAFFS_TRACE_OS,
-			  (TSTR("yaffs_readdir: %s inode %d\n"),
-			   name, yaffs_get_obj_inode(l)));
-
-			yaffs_gross_unlock(dev);
-
-			if (filldir(dirent,
-				    name,
-				    strlen(name),
-				    offset, this_inode, this_type) < 0) {
-				yaffs_gross_lock(dev);
-				goto out;
-			}
-
-			yaffs_gross_lock(dev);
-
-			offset++;
-			f->f_pos++;
-		}
-		yaffs_search_advance(sc);
-	}
-
-out:
-	yaffs_search_end(sc);
-	yaffs_dev_to_lc(dev)->readdir_process = NULL;
-	yaffs_gross_unlock(dev);
-
-	return ret_val;
-}
-
-/*
- * File creation. Allocate an inode, and we're done..
- */
-
-#define YCRED(x) (x->cred)
-
-static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
-		       dev_t rdev)
-{
-	struct inode *inode;
-
-	struct yaffs_obj *obj = NULL;
-	struct yaffs_dev *dev;
-
-	struct yaffs_obj *parent = yaffs_inode_to_obj(dir);
-
-	int error = -ENOSPC;
-	uid_t uid = YCRED(current)->fsuid;
-	gid_t gid =
-	    (dir->i_mode & S_ISGID) ? dir->i_gid : YCRED(current)->fsgid;
-
-	if ((dir->i_mode & S_ISGID) && S_ISDIR(mode))
-		mode |= S_ISGID;
-
-	if (parent) {
-		T(YAFFS_TRACE_OS,
-		  (TSTR("yaffs_mknod: parent object %d type %d\n"),
-		   parent->obj_id, parent->variant_type));
-	} else {
-		T(YAFFS_TRACE_OS,
-		  (TSTR("yaffs_mknod: could not get parent object\n")));
-		return -EPERM;
-	}
-
-	T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making oject for %s, "
-				"mode %x dev %x\n"),
-			   dentry->d_name.name, mode, rdev));
-
-	dev = parent->my_dev;
-
-	yaffs_gross_lock(dev);
-
-	switch (mode & S_IFMT) {
-	default:
-		/* Special (socket, fifo, device...) */
-		T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making special\n")));
-		obj =
-		    yaffs_create_special(parent, dentry->d_name.name, mode, uid,
-					 gid, old_encode_dev(rdev));
-		break;
-	case S_IFREG:		/* file          */
-		T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making file\n")));
-		obj = yaffs_create_file(parent, dentry->d_name.name, mode, uid,
-					gid);
-		break;
-	case S_IFDIR:		/* directory */
-		T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making directory\n")));
-		obj = yaffs_create_dir(parent, dentry->d_name.name, mode,
-				       uid, gid);
-		break;
-	case S_IFLNK:		/* symlink */
-		T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making symlink\n")));
-		obj = NULL;	/* Do we ever get here? */
-		break;
-	}
-
-	/* Can not call yaffs_get_inode() with gross lock held */
-	yaffs_gross_unlock(dev);
-
-	if (obj) {
-		inode = yaffs_get_inode(dir->i_sb, mode, rdev, obj);
-		d_instantiate(dentry, inode);
-		update_dir_time(dir);
-		T(YAFFS_TRACE_OS,
-		  (TSTR("yaffs_mknod created object %d count = %d\n"),
-		   obj->obj_id, atomic_read(&inode->i_count)));
-		error = 0;
-		yaffs_fill_inode_from_obj(dir, parent);
-	} else {
-		T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod failed making object\n")));
-		error = -ENOMEM;
-	}
-
-	return error;
-}
-
-static int yaffs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
-{
-	int ret_val;
-	T(YAFFS_TRACE_OS, (TSTR("yaffs_mkdir\n")));
-	ret_val = yaffs_mknod(dir, dentry, mode | S_IFDIR, 0);
-	return ret_val;
-}
-
-static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode,
-			struct nameidata *n)
-{
-	T(YAFFS_TRACE_OS, (TSTR("yaffs_create\n")));
-	return yaffs_mknod(dir, dentry, mode | S_IFREG, 0);
-}
-
-static int yaffs_unlink(struct inode *dir, struct dentry *dentry)
+static int yaffs_write_end(struct file *filp, struct address_space *mapping,
+			   loff_t pos, unsigned len, unsigned copied,
+			   struct page *pg, void *fsdadata)
 {
-	int ret_val;
+	int ret = 0;
+	void *addr, *kva;
+	uint32_t offset_into_page = pos & (PAGE_CACHE_SIZE - 1);
 
-	struct yaffs_dev *dev;
-	struct yaffs_obj *obj;
+	kva = kmap(pg);
+	addr = kva + offset_into_page;
 
 	T(YAFFS_TRACE_OS,
-	  (TSTR("yaffs_unlink %d:%s\n"),
-	   (int)(dir->i_ino), dentry->d_name.name));
-	obj = yaffs_inode_to_obj(dir);
-	dev = obj->my_dev;
-
-	yaffs_gross_lock(dev);
-
-	ret_val = yaffs_unlinker(obj, dentry->d_name.name);
-
-	if (ret_val == YAFFS_OK) {
-		dentry->d_inode->i_nlink--;
-		dir->i_version++;
-		yaffs_gross_unlock(dev);
-		mark_inode_dirty(dentry->d_inode);
-		update_dir_time(dir);
-		return 0;
-	}
-	yaffs_gross_unlock(dev);
-	return -ENOTEMPTY;
-}
-
-/*
- * Create a link...
- */
-static int yaffs_link(struct dentry *old_dentry, struct inode *dir,
-		      struct dentry *dentry)
-{
-	struct inode *inode = old_dentry->d_inode;
-	struct yaffs_obj *obj = NULL;
-	struct yaffs_obj *link = NULL;
-	struct yaffs_dev *dev;
-
-	T(YAFFS_TRACE_OS, (TSTR("yaffs_link\n")));
-
-	obj = yaffs_inode_to_obj(inode);
-	dev = obj->my_dev;
-
-	yaffs_gross_lock(dev);
+	  ("yaffs_write_end addr %p pos %x n_bytes %d\n",
+	   addr, (unsigned)pos, copied));
 
-	if (!S_ISDIR(inode->i_mode))	/* Don't link directories */
-		link =
-		    yaffs_link_obj(yaffs_inode_to_obj(dir), dentry->d_name.name,
-				   obj);
+	ret = yaffs_file_write(filp, addr, copied, &pos);
 
-	if (link) {
-		old_dentry->d_inode->i_nlink = yaffs_get_obj_link_count(obj);
-		d_instantiate(dentry, old_dentry->d_inode);
-		atomic_inc(&old_dentry->d_inode->i_count);
+	if (ret != copied) {
 		T(YAFFS_TRACE_OS,
-		  (TSTR("yaffs_link link count %d i_count %d\n"),
-		   old_dentry->d_inode->i_nlink,
-		   atomic_read(&old_dentry->d_inode->i_count)));
-	}
-
-	yaffs_gross_unlock(dev);
-
-	if (link) {
-		update_dir_time(dir);
-		return 0;
-	}
-
-	return -EPERM;
-}
-
-static int yaffs_symlink(struct inode *dir, struct dentry *dentry,
-			 const char *symname)
-{
-	struct yaffs_obj *obj;
-	struct yaffs_dev *dev;
-	uid_t uid = YCRED(current)->fsuid;
-	gid_t gid =
-	    (dir->i_mode & S_ISGID) ? dir->i_gid : YCRED(current)->fsgid;
-
-	T(YAFFS_TRACE_OS, (TSTR("yaffs_symlink\n")));
-
-	dev = yaffs_inode_to_obj(dir)->my_dev;
-	yaffs_gross_lock(dev);
-	obj = yaffs_create_symlink(yaffs_inode_to_obj(dir), dentry->d_name.name,
-				   S_IFLNK | S_IRWXUGO, uid, gid, symname);
-	yaffs_gross_unlock(dev);
-
-	if (obj) {
-		struct inode *inode;
-
-		inode = yaffs_get_inode(dir->i_sb, obj->yst_mode, 0, obj);
-		d_instantiate(dentry, inode);
-		update_dir_time(dir);
-		T(YAFFS_TRACE_OS, (TSTR("symlink created OK\n")));
-		return 0;
-	} else {
-		T(YAFFS_TRACE_OS, (TSTR("symlink not created\n")));
-	}
-
-	return -ENOMEM;
-}
-
-static int yaffs_sync_object(struct file *file, int datasync)
-{
-
-	struct yaffs_obj *obj;
-	struct yaffs_dev *dev;
-	struct dentry *dentry = file->f_path.dentry;
-
-	obj = yaffs_dentry_to_obj(dentry);
-
-	dev = obj->my_dev;
-
-	T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC, (TSTR("yaffs_sync_object\n")));
-	yaffs_gross_lock(dev);
-	yaffs_flush_file(obj, 1, datasync);
-	yaffs_gross_unlock(dev);
-	return 0;
-}
-
-/*
- * The VFS layer already does all the dentry stuff for rename.
- *
- * NB: POSIX says you can rename an object over an old object of the same name
- */
-static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry,
-			struct inode *new_dir, struct dentry *new_dentry)
-{
-	struct yaffs_dev *dev;
-	int ret_val = YAFFS_FAIL;
-	struct yaffs_obj *target;
-
-	T(YAFFS_TRACE_OS, (TSTR("yaffs_rename\n")));
-	dev = yaffs_inode_to_obj(old_dir)->my_dev;
-
-	yaffs_gross_lock(dev);
-
-	/* Check if the target is an existing directory that is not empty. */
-	target = yaffs_find_by_name(yaffs_inode_to_obj(new_dir),
-				    new_dentry->d_name.name);
-
-	if (target && target->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY &&
-	    !list_empty(&target->variant.dir_variant.children)) {
-
-		T(YAFFS_TRACE_OS, (TSTR("target is non-empty dir\n")));
-
-		ret_val = YAFFS_FAIL;
-	} else {
-		/* Now does unlinking internally using shadowing mechanism */
-		T(YAFFS_TRACE_OS, (TSTR("calling yaffs_rename_obj\n")));
-
-		ret_val = yaffs_rename_obj(yaffs_inode_to_obj(old_dir),
-					   old_dentry->d_name.name,
-					   yaffs_inode_to_obj(new_dir),
-					   new_dentry->d_name.name);
-	}
-	yaffs_gross_unlock(dev);
-
-	if (ret_val == YAFFS_OK) {
-		if (target) {
-			new_dentry->d_inode->i_nlink--;
-			mark_inode_dirty(new_dentry->d_inode);
-		}
-
-		update_dir_time(old_dir);
-		if (old_dir != new_dir)
-			update_dir_time(new_dir);
-		return 0;
+		  (TSTR("yaffs_write_end not same size ret %d  copied %d\n"),
+		   ret, copied));
+		SetPageError(pg);
 	} else {
-		return -ENOTEMPTY;
-	}
-}
-
-static int yaffs_setattr(struct dentry *dentry, struct iattr *attr)
-{
-	struct inode *inode = dentry->d_inode;
-	int error = 0;
-	struct yaffs_dev *dev;
-
-	T(YAFFS_TRACE_OS,
-	  (TSTR("yaffs_setattr of object %d\n"),
-	   yaffs_inode_to_obj(inode)->obj_id));
-
-	/* Fail if a requested resize >= 2GB */
-	if (attr->ia_valid & ATTR_SIZE && (attr->ia_size >> 31))
-		error = -EINVAL;
-
-	if (error == 0)
-		error = inode_change_ok(inode, attr);
-	if (error == 0) {
-		int result;
-		if (!error) {
-			error = yaffs_vfs_setattr(inode, attr);
-			T(YAFFS_TRACE_OS, (TSTR("inode_setattr called\n")));
-			if (attr->ia_valid & ATTR_SIZE) {
-				yaffs_vfs_setsize(inode, attr->ia_size);
-				inode->i_blocks = (inode->i_size + 511) >> 9;
-			}
-		}
-		dev = yaffs_inode_to_obj(inode)->my_dev;
-		if (attr->ia_valid & ATTR_SIZE) {
-			T(YAFFS_TRACE_OS, (TSTR("resize to %d(%x)\n"),
-					   (int)(attr->ia_size),
-					   (int)(attr->ia_size)));
-		}
-		yaffs_gross_lock(dev);
-		result = yaffs_set_attribs(yaffs_inode_to_obj(inode), attr);
-		if (result == YAFFS_OK) {
-			error = 0;
-		} else {
-			error = -EPERM;
-		}
-		yaffs_gross_unlock(dev);
-
-	}
-
-	T(YAFFS_TRACE_OS, (TSTR("yaffs_setattr done returning %d\n"), error));
-
-	return error;
-}
-
-#ifdef CONFIG_YAFFS_XATTR
-static int yaffs_setxattr(struct dentry *dentry, const char *name,
-		   const void *value, size_t size, int flags)
-{
-	struct inode *inode = dentry->d_inode;
-	int error = 0;
-	struct yaffs_dev *dev;
-	struct yaffs_obj *obj = yaffs_inode_to_obj(inode);
-
-	T(YAFFS_TRACE_OS, (TSTR("yaffs_setxattr of object %d\n"), obj->obj_id));
-
-	if (error == 0) {
-		int result;
-		dev = obj->my_dev;
-		yaffs_gross_lock(dev);
-		result = yaffs_set_xattrib(obj, name, value, size, flags);
-		if (result == YAFFS_OK)
-			error = 0;
-		else if (result < 0)
-			error = result;
-		yaffs_gross_unlock(dev);
-
-	}
-	T(YAFFS_TRACE_OS, (TSTR("yaffs_setxattr done returning %d\n"), error));
-
-	return error;
-}
-
-static ssize_t yaffs_getxattr(struct dentry * dentry, const char *name, void *buff,
-		       size_t size)
-{
-	struct inode *inode = dentry->d_inode;
-	int error = 0;
-	struct yaffs_dev *dev;
-	struct yaffs_obj *obj = yaffs_inode_to_obj(inode);
-
-	T(YAFFS_TRACE_OS,
-	  (TSTR("yaffs_getxattr \"%s\" from object %d\n"), name, obj->obj_id));
-
-	if (error == 0) {
-		dev = obj->my_dev;
-		yaffs_gross_lock(dev);
-		error = yaffs_get_xattrib(obj, name, buff, size);
-		yaffs_gross_unlock(dev);
-
-	}
-	T(YAFFS_TRACE_OS, (TSTR("yaffs_getxattr done returning %d\n"), error));
-
-	return error;
-}
-
-static int yaffs_removexattr(struct dentry *dentry, const char *name)
-{
-	struct inode *inode = dentry->d_inode;
-	int error = 0;
-	struct yaffs_dev *dev;
-	struct yaffs_obj *obj = yaffs_inode_to_obj(inode);
-
-	T(YAFFS_TRACE_OS,
-	  (TSTR("yaffs_removexattr of object %d\n"), obj->obj_id));
-
-	if (error == 0) {
-		int result;
-		dev = obj->my_dev;
-		yaffs_gross_lock(dev);
-		result = yaffs_remove_xattrib(obj, name);
-		if (result == YAFFS_OK)
-			error = 0;
-		else if (result < 0)
-			error = result;
-		yaffs_gross_unlock(dev);
-
+		/* Nothing */
 	}
-	T(YAFFS_TRACE_OS,
-	  (TSTR("yaffs_removexattr done returning %d\n"), error));
 
-	return error;
-}
-
-static ssize_t yaffs_listxattr(struct dentry * dentry, char *buff, size_t size)
-{
-	struct inode *inode = dentry->d_inode;
-	int error = 0;
-	struct yaffs_dev *dev;
-	struct yaffs_obj *obj = yaffs_inode_to_obj(inode);
-
-	T(YAFFS_TRACE_OS,
-	  (TSTR("yaffs_listxattr of object %d\n"), obj->obj_id));
-
-	if (error == 0) {
-		dev = obj->my_dev;
-		yaffs_gross_lock(dev);
-		error = yaffs_list_xattrib(obj, buff, size);
-		yaffs_gross_unlock(dev);
-
-	}
-	T(YAFFS_TRACE_OS, (TSTR("yaffs_listxattr done returning %d\n"), error));
+	kunmap(pg);
 
-	return error;
+	yaffs_release_space(filp);
+	unlock_page(pg);
+	page_cache_release(pg);
+	return ret;
 }
 
-#endif
-
 static int yaffs_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
 	struct yaffs_dev *dev = yaffs_dentry_to_obj(dentry)->my_dev;
@@ -1950,92 +1751,11 @@ static int yaffs_sync_fs(struct super_block *sb, int wait)
 	return 0;
 }
 
-static struct inode *yaffs_iget(struct super_block *sb, unsigned long ino)
-{
-	struct inode *inode;
-	struct yaffs_obj *obj;
-	struct yaffs_dev *dev = yaffs_super_to_dev(sb);
-
-	T(YAFFS_TRACE_OS, (TSTR("yaffs_iget for %lu\n"), ino));
-
-	inode = iget_locked(sb, ino);
-	if (!inode)
-		return ERR_PTR(-ENOMEM);
-	if (!(inode->i_state & I_NEW))
-		return inode;
-
-	/* NB This is called as a side effect of other functions, but
-	 * we had to release the lock to prevent deadlocks, so
-	 * need to lock again.
-	 */
-
-	yaffs_gross_lock(dev);
-
-	obj = yaffs_find_by_number(dev, inode->i_ino);
-
-	yaffs_fill_inode_from_obj(inode, obj);
-
-	yaffs_gross_unlock(dev);
-
-	unlock_new_inode(inode);
-	return inode;
-}
 
 static LIST_HEAD(yaffs_context_list);
 struct mutex yaffs_context_lock;
 
-static void yaffs_put_super(struct super_block *sb)
-{
-	struct yaffs_dev *dev = yaffs_super_to_dev(sb);
-
-	T(YAFFS_TRACE_OS, (TSTR("yaffs_put_super\n")));
-
-	T(YAFFS_TRACE_OS | YAFFS_TRACE_BACKGROUND,
-	  (TSTR("Shutting down yaffs background thread\n")));
-	yaffs_bg_stop(dev);
-	T(YAFFS_TRACE_OS | YAFFS_TRACE_BACKGROUND,
-	  (TSTR("yaffs background thread shut down\n")));
-
-	yaffs_gross_lock(dev);
-
-	yaffs_flush_super(sb, 1);
-
-	if (yaffs_dev_to_lc(dev)->put_super_fn)
-		yaffs_dev_to_lc(dev)->put_super_fn(sb);
-
-	yaffs_deinitialise(dev);
-
-	yaffs_gross_unlock(dev);
-	mutex_lock(&yaffs_context_lock);
-	list_del_init(&(yaffs_dev_to_lc(dev)->context_list));
-	mutex_unlock(&yaffs_context_lock);
-
-	if (yaffs_dev_to_lc(dev)->spare_buffer) {
-		YFREE(yaffs_dev_to_lc(dev)->spare_buffer);
-		yaffs_dev_to_lc(dev)->spare_buffer = NULL;
-	}
-
-	kfree(dev);
-}
-
-static void yaffs_mtd_put_super(struct super_block *sb)
-{
-	struct mtd_info *mtd = yaffs_dev_to_mtd(yaffs_super_to_dev(sb));
-
-	if (mtd->sync)
-		mtd->sync(mtd);
-
-	put_mtd_device(mtd);
-}
-
-static void yaffs_touch_super(struct yaffs_dev *dev)
-{
-	struct super_block *sb = yaffs_dev_to_lc(dev)->super;
 
-	T(YAFFS_TRACE_OS, (TSTR("yaffs_touch_super() sb = %p\n"), sb));
-	if (sb)
-		sb->s_dirt = 1;
-}
 
 struct yaffs_options {
 	int inband_tags;
@@ -2114,6 +1834,183 @@ static int yaffs_parse_options(struct yaffs_options *options,
 	return error;
 }
 
+static struct address_space_operations yaffs_file_address_operations = {
+	.readpage = yaffs_readpage,
+	.writepage = yaffs_writepage,
+	.write_begin = yaffs_write_begin,
+	.write_end = yaffs_write_end,
+};
+
+
+
+static const struct inode_operations yaffs_file_inode_operations = {
+	.setattr = yaffs_setattr,
+#ifdef CONFIG_YAFFS_XATTR
+	.setxattr = yaffs_setxattr,
+	.getxattr = yaffs_getxattr,
+	.listxattr = yaffs_listxattr,
+	.removexattr = yaffs_removexattr,
+#endif
+};
+
+static const struct inode_operations yaffs_symlink_inode_operations = {
+	.readlink = yaffs_readlink,
+	.follow_link = yaffs_follow_link,
+	.put_link = yaffs_put_link,
+	.setattr = yaffs_setattr,
+#ifdef CONFIG_YAFFS_XATTR
+	.setxattr = yaffs_setxattr,
+	.getxattr = yaffs_getxattr,
+	.listxattr = yaffs_listxattr,
+	.removexattr = yaffs_removexattr,
+#endif
+};
+
+static void yaffs_fill_inode_from_obj(struct inode *inode,
+				      struct yaffs_obj *obj)
+{
+	if (inode && obj) {
+
+		/* Check mode against the variant type and attempt to repair if broken. */
+		u32 mode = obj->yst_mode;
+		switch (obj->variant_type) {
+		case YAFFS_OBJECT_TYPE_FILE:
+			if (!S_ISREG(mode)) {
+				obj->yst_mode &= ~S_IFMT;
+				obj->yst_mode |= S_IFREG;
+			}
+
+			break;
+		case YAFFS_OBJECT_TYPE_SYMLINK:
+			if (!S_ISLNK(mode)) {
+				obj->yst_mode &= ~S_IFMT;
+				obj->yst_mode |= S_IFLNK;
+			}
+
+			break;
+		case YAFFS_OBJECT_TYPE_DIRECTORY:
+			if (!S_ISDIR(mode)) {
+				obj->yst_mode &= ~S_IFMT;
+				obj->yst_mode |= S_IFDIR;
+			}
+
+			break;
+		case YAFFS_OBJECT_TYPE_UNKNOWN:
+		case YAFFS_OBJECT_TYPE_HARDLINK:
+		case YAFFS_OBJECT_TYPE_SPECIAL:
+		default:
+			/* TODO? */
+			break;
+		}
+
+		inode->i_flags |= S_NOATIME;
+
+		inode->i_ino = obj->obj_id;
+		inode->i_mode = obj->yst_mode;
+		inode->i_uid = obj->yst_uid;
+		inode->i_gid = obj->yst_gid;
+
+		inode->i_rdev = old_decode_dev(obj->yst_rdev);
+
+		inode->i_atime.tv_sec = (time_t) (obj->yst_atime);
+		inode->i_atime.tv_nsec = 0;
+		inode->i_mtime.tv_sec = (time_t) obj->yst_mtime;
+		inode->i_mtime.tv_nsec = 0;
+		inode->i_ctime.tv_sec = (time_t) obj->yst_ctime;
+		inode->i_ctime.tv_nsec = 0;
+		inode->i_size = yaffs_get_obj_length(obj);
+		inode->i_blocks = (inode->i_size + 511) >> 9;
+
+		inode->i_nlink = yaffs_get_obj_link_count(obj);
+
+		T(YAFFS_TRACE_OS,
+		  (TSTR
+		   ("yaffs_fill_inode mode %x uid %d gid %d size %d count %d\n"),
+		   inode->i_mode, inode->i_uid, inode->i_gid,
+		   (int)inode->i_size, atomic_read(&inode->i_count)));
+
+		switch (obj->yst_mode & S_IFMT) {
+		default:	/* fifo, device or socket */
+			init_special_inode(inode, obj->yst_mode,
+					   old_decode_dev(obj->yst_rdev));
+			break;
+		case S_IFREG:	/* file */
+			inode->i_op = &yaffs_file_inode_operations;
+			inode->i_fop = &yaffs_file_operations;
+			inode->i_mapping->a_ops =
+			    &yaffs_file_address_operations;
+			break;
+		case S_IFDIR:	/* directory */
+			inode->i_op = &yaffs_dir_inode_operations;
+			inode->i_fop = &yaffs_dir_operations;
+			break;
+		case S_IFLNK:	/* symlink */
+			inode->i_op = &yaffs_symlink_inode_operations;
+			break;
+		}
+
+		yaffs_inode_to_obj_lv(inode) = obj;
+
+		obj->my_inode = inode;
+
+	} else {
+		T(YAFFS_TRACE_OS,
+		  (TSTR("yaffs_fill_inode invalid parameters\n")));
+	}
+}
+
+static void yaffs_put_super(struct super_block *sb)
+{
+	struct yaffs_dev *dev = yaffs_super_to_dev(sb);
+
+	T(YAFFS_TRACE_OS, (TSTR("yaffs_put_super\n")));
+
+	T(YAFFS_TRACE_OS | YAFFS_TRACE_BACKGROUND,
+	  (TSTR("Shutting down yaffs background thread\n")));
+	yaffs_bg_stop(dev);
+	T(YAFFS_TRACE_OS | YAFFS_TRACE_BACKGROUND,
+	  (TSTR("yaffs background thread shut down\n")));
+
+	yaffs_gross_lock(dev);
+
+	yaffs_flush_super(sb, 1);
+
+	if (yaffs_dev_to_lc(dev)->put_super_fn)
+		yaffs_dev_to_lc(dev)->put_super_fn(sb);
+
+	yaffs_deinitialise(dev);
+
+	yaffs_gross_unlock(dev);
+	mutex_lock(&yaffs_context_lock);
+	list_del_init(&(yaffs_dev_to_lc(dev)->context_list));
+	mutex_unlock(&yaffs_context_lock);
+
+	if (yaffs_dev_to_lc(dev)->spare_buffer) {
+		kfree(yaffs_dev_to_lc(dev)->spare_buffer);
+		yaffs_dev_to_lc(dev)->spare_buffer = NULL;
+	}
+
+	kfree(dev);
+}
+
+static void yaffs_mtd_put_super(struct super_block *sb)
+{
+	struct mtd_info *mtd = yaffs_dev_to_mtd(yaffs_super_to_dev(sb));
+
+	if (mtd->sync)
+		mtd->sync(mtd);
+
+	put_mtd_device(mtd);
+}
+
+static const struct super_operations yaffs_super_ops = {
+	.statfs = yaffs_statfs,
+	.put_super = yaffs_put_super,
+	.evict_inode = yaffs_evict_inode,
+	.sync_fs = yaffs_sync_fs,
+	.write_super = yaffs_write_super,
+};
+
 static struct super_block *yaffs_internal_read_super(int yaffs_version,
 						     struct super_block *sb,
 						     void *data, int silent)
@@ -2374,7 +2271,8 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
 		param->read_chunk_tags_fn = nandmtd2_read_chunk_tags;
 		param->bad_block_fn = nandmtd2_mark_block_bad;
 		param->query_block_fn = nandmtd2_query_block;
-		yaffs_dev_to_lc(dev)->spare_buffer = YMALLOC(mtd->oobsize);
+		yaffs_dev_to_lc(dev)->spare_buffer = 
+		                kmalloc(mtd->oobsize, GFP_NOFS);
 		param->is_yaffs2 = 1;
 		param->total_bytes_per_chunk = mtd->writesize;
 		param->chunks_per_block = mtd->erasesize / mtd->writesize;
diff --git a/yaffs_yaffs1.c b/yaffs_yaffs1.c
index b6c43e5..4d10096 100644
--- a/yaffs_yaffs1.c
+++ b/yaffs_yaffs1.c
@@ -86,7 +86,7 @@ int yaffs1_scan(struct yaffs_dev *dev)
 	for (blk = dev->internal_start_block;
 	     !alloc_failed && blk <= dev->internal_end_block; blk++) {
 
-		YYIELD();
+		cond_resched();
 
 		bi = yaffs_get_block_info(dev, blk);
 		state = bi->block_state;
@@ -217,9 +217,9 @@ int yaffs1_scan(struct yaffs_dev *dev)
 
 					struct yaffs_shadow_fixer *fixer;
 					fixer =
-					    YMALLOC(sizeof
-						    (struct
-						     yaffs_shadow_fixer));
+						kmalloc(sizeof
+						(struct yaffs_shadow_fixer),
+						GFP_NOFS);
 					if (fixer) {
 						fixer->next = shadow_fixers;
 						shadow_fixers = fixer;
@@ -422,7 +422,7 @@ int yaffs1_scan(struct yaffs_dev *dev)
 			if (obj)
 				yaffs_update_oh(obj, NULL, 1, 0, 0, NULL);
 
-			YFREE(fixer);
+			kfree(fixer);
 		}
 	}
 
diff --git a/yaffs_yaffs2.c b/yaffs_yaffs2.c
index 4f11765..87733fd 100644
--- a/yaffs_yaffs2.c
+++ b/yaffs_yaffs2.c
@@ -1001,11 +1001,12 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev)
 
 	dev->seq_number = YAFFS_LOWEST_SEQUENCE_NUMBER;
 
-	block_index = YMALLOC(n_blocks * sizeof(struct yaffs_block_index));
+	block_index = kmalloc(n_blocks * sizeof(struct yaffs_block_index),
+			GFP_NOFS);
 
 	if (!block_index) {
 		block_index =
-		    YMALLOC_ALT(n_blocks * sizeof(struct yaffs_block_index));
+		    vmalloc(n_blocks * sizeof(struct yaffs_block_index));
 		alt_block_index = 1;
 	}
 
@@ -1082,13 +1083,13 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev)
 	T(YAFFS_TRACE_SCAN,
 	  (TSTR("%d blocks to be sorted..." TENDSTR), n_to_scan));
 
-	YYIELD();
+	cond_resched();
 
 	/* Sort the blocks by sequence number */
-	yaffs_sort(block_index, n_to_scan, sizeof(struct yaffs_block_index),
-		   yaffs2_ybicmp);
+	sort(block_index, n_to_scan, sizeof(struct yaffs_block_index),
+		   yaffs2_ybicmp, NULL);
 
-	YYIELD();
+	cond_resched();
 
 	T(YAFFS_TRACE_SCAN, (TSTR("...done" TENDSTR)));
 
@@ -1103,7 +1104,7 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev)
 	     block_iter--) {
 		/* Cooperative multitasking! This loop can run for so
 		   long that watchdog timers expire. */
-		YYIELD();
+		cond_resched();
 
 		/* get the block to scan in the correct order */
 		blk = block_index[block_iter].block;
@@ -1598,9 +1599,9 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev)
 	yaffs_skip_rest_of_block(dev);
 
 	if (alt_block_index)
-		YFREE_ALT(block_index);
+		vfree(block_index);
 	else
-		YFREE(block_index);
+		kfree(block_index);
 
 	/* Ok, we've done all the scanning.
 	 * Fix up the hard link chains.
diff --git a/yportenv_multi.h b/yportenv_multi.h
index 4b058a7..79c7462 100644
--- a/yportenv_multi.h
+++ b/yportenv_multi.h
@@ -58,29 +58,12 @@
 #define YCHAR char
 #define YUCHAR unsigned char
 #define _Y(x)     x
-#define yaffs_strcat(a, b)     strcat(a, b)
-#define yaffs_strcpy(a, b)     strcpy(a, b)
-#define yaffs_strncpy(a, b, c) strncpy(a, b, c)
-#define yaffs_strncmp(a, b, c) strncmp(a, b, c)
-#define yaffs_strnlen(s,m)	strnlen(s,m)
-#define yaffs_sprintf	       sprintf
-#define yaffs_toupper(a)       toupper(a)
-#define yaffs_sort(base, n, sz, cmp_fn) sort(base, n, sz, cmp_fn, NULL)
 
 #define Y_INLINE __inline__
 
 #define YAFFS_LOSTNFOUND_NAME		"lost+found"
 #define YAFFS_LOSTNFOUND_PREFIX		"obj"
 
-/* #define YPRINTF(x) printk x */
-#define YMALLOC(x) kmalloc(x, GFP_NOFS)
-#define YFREE(x)   kfree(x)
-#define YMALLOC_ALT(x) vmalloc(x)
-#define YFREE_ALT(x)   vfree(x)
-#define YMALLOC_DMA(x) YMALLOC(x)
-
-#define YYIELD() schedule()
-#define Y_DUMP_STACK() dump_stack()
 
 #define YAFFS_ROOT_MODE			0755
 #define YAFFS_LOSTNFOUND_MODE		0700
@@ -94,7 +77,7 @@
 #endif
 
 #define yaffs_sum_cmp(x, y) ((x) == (y))
-#define yaffs_strcmp(a, b) strcmp(a, b)
+#define strcmp(a, b) strcmp(a, b)
 
 #define TENDSTR "\n"
 #define TSTR(x) KERN_DEBUG x
@@ -119,19 +102,19 @@
 #include "stdio.h"
 #include "string.h"
 
-#define YMALLOC(x) malloc(x)
-#define YFREE(x)   free(x)
-#define YMALLOC_ALT(x) malloc(x)
-#define YFREE_ALT(x) free(x)
+#define kmalloc(x) malloc(x)
+#define kfree(x)   free(x)
+#define kmalloc_ALT(x) malloc(x)
+#define kfree_ALT(x) free(x)
 
 #define YCHAR char
 #define YUCHAR unsigned char
 #define _Y(x)     x
-#define yaffs_strcat(a, b)     strcat(a, b)
-#define yaffs_strcpy(a, b)     strcpy(a, b)
-#define yaffs_strncpy(a, b, c) strncpy(a, b, c)
-#define yaffs_strnlen(s,m)	       strnlen(s,m)
-#define yaffs_sprintf	       sprintf
+#define strcat(a, b)     strcat(a, b)
+#define strcpy(a, b)     strcpy(a, b)
+#define strncpy(a, b, c) strncpy(a, b, c)
+#define strnlen(s,m)	       strnlen(s,m)
+#define sprintf	       sprintf
 #define yaffs_toupper(a)       toupper(a)
 
 #define Y_INLINE inline
@@ -151,7 +134,7 @@
 #define YAFFS_LOSTNFOUND_MODE		0700
 
 #define yaffs_sum_cmp(x, y) ((x) == (y))
-#define yaffs_strcmp(a, b) strcmp(a, b)
+#define strcmp(a, b) strcmp(a, b)
 
 #else
 /* Should have specified a configuration type */
diff --git a/yportenv_single.h b/yportenv_single.h
index 8fd0da5..378b73a 100644
--- a/yportenv_single.h
+++ b/yportenv_single.h
@@ -34,29 +34,12 @@
 #define YCHAR char
 #define YUCHAR unsigned char
 #define _Y(x)     x
-#define yaffs_strcat(a, b)     strcat(a, b)
-#define yaffs_strcpy(a, b)     strcpy(a, b)
-#define yaffs_strncpy(a, b, c) strncpy(a, b, c)
-#define yaffs_strncmp(a, b, c) strncmp(a, b, c)
-#define yaffs_strnlen(s,m)	strnlen(s,m)
-#define yaffs_sprintf	       sprintf
-#define yaffs_toupper(a)       toupper(a)
-
-#define yaffs_sort(base, n, sz, cmp_fn)	sort(base, n, sz, cmp_fn, NULL)
 
 #define Y_INLINE __inline__
 
 #define YAFFS_LOSTNFOUND_NAME		"lost+found"
 #define YAFFS_LOSTNFOUND_PREFIX		"obj"
 
-#define YMALLOC(x) kmalloc(x, GFP_NOFS)
-#define YFREE(x)   kfree(x)
-#define YMALLOC_ALT(x) vmalloc(x)
-#define YFREE_ALT(x)   vfree(x)
-#define YMALLOC_DMA(x) YMALLOC(x)
-
-#define YYIELD() schedule()
-#define Y_DUMP_STACK() dump_stack()
 
 #define YAFFS_ROOT_MODE			0755
 #define YAFFS_LOSTNFOUND_MODE		0700
@@ -64,8 +47,6 @@
 #define Y_CURRENT_TIME CURRENT_TIME.tv_sec
 #define Y_TIME_CONVERT(x) (x).tv_sec
 
-#define yaffs_sum_cmp(x, y) ((x) == (y))
-#define yaffs_strcmp(a, b) strcmp(a, b)
 
 #define TENDSTR "\n"
 #define TSTR(x) KERN_DEBUG x