X-Git-Url: http://www.aleph1.co.uk/gitweb/?p=yaffs2.git;a=blobdiff_plain;f=direct%2Fyaffsfs.c;h=fffc11eece7b691892c767c5122a04e556374514;hp=22948881b5081e1eb8b8da97674b952f6c852a2d;hb=80f85303d264f804ea288e1995280345804ec01c;hpb=d4264d6b99c4b943c3217347ec73e1f6bef49a63

diff --git a/direct/yaffsfs.c b/direct/yaffsfs.c
index 2294888..fffc11e 100644
--- a/direct/yaffsfs.c
+++ b/direct/yaffsfs.c
@@ -1,7 +1,7 @@
 /*
  * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
  *
- * Copyright (C) 2002-2010 Aleph One Ltd.
+ * Copyright (C) 2002-2011 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
  *
  * Created by Charles Manning <charles@aleph1.co.uk>
@@ -17,7 +17,7 @@
 #include "yportenv.h"
 #include "yaffs_trace.h"
 
-#include <string.h> /* for memset */
+#include "string.h"
 
 #define YAFFSFS_MAX_SYMLINK_DEREFERENCES 5
 
@@ -31,42 +31,76 @@
 #define YAFFSFS_RW_SIZE  (1<<YAFFSFS_RW_SHIFT)
 
 /* Some forward references */
-static yaffs_Object *yaffsfs_FindObject(yaffs_Object *relativeDirectory, const YCHAR *path, int symDepth, int getEquiv);
-static void yaffsfs_RemoveObjectCallback(yaffs_Object *obj);
+static struct yaffs_obj *yaffsfs_FindObject(struct yaffs_obj *relativeDirectory,
+			const YCHAR *path,
+			int symDepth, int getEquiv,
+			struct yaffs_obj **dirOut,
+			int *notDir, int *loop);
+
+static void yaffsfs_RemoveObjectCallback(struct yaffs_obj *obj);
 
 unsigned int yaffs_wr_attempts;
 
 /*
  * Handle management.
  * There are open inodes in yaffsfs_Inode.
- * There are open handles in yaffsfs_Handle.
+ * There are open file descriptors in yaffsfs_FileDes.
+ * There are open handles in yaffsfs_FileDes.
  *
  * Things are structured this way to be like the Linux VFS model
  * so that interactions with the yaffs guts calls are similar.
  * That means more common code paths and less special code.
  * That means better testing etc.
+ *
+ * We have 3 layers because:
+ * A handle is different than an fd because you can use dup()
+ * to create a new handle that accesses the *same* fd. The two
+ * handles will use the same offset (part of the fd). We only close
+ * down the fd when there are no more handles accessing it.
+ *
+ * More than one fd can currently access one file, but each fd
+ * has its own permsiions and offset.
  */
 
 typedef struct {
 	int count;	/* Number of handles accessing this inode */
-	yaffs_Object *iObj;
+	struct yaffs_obj *iObj;
 } yaffsfs_Inode;
 
 typedef struct{
-	__u8 	reading:1;
-	__u8 	writing:1;
-	__u8 	append:1;
-	__u8	shareRead:1;
-	__u8	shareWrite:1;
+	u8 	reading:1;
+	u8 	writing:1;
+	u8 	append:1;
+	u8	shareRead:1;
+	u8	shareWrite:1;
 	int	inodeId:12;	/* Index to corresponding yaffsfs_Inode */
-	int	useCount:10;	/* Use count for this handle */
-	__u32 position;		/* current position in file */
-}yaffsfs_Handle;
+	int	handleCount:10;	/* Number of handles for this fd */
+	loff_t	position;		/* current position in file */
+}yaffsfs_FileDes;
+
+typedef struct {
+	short int fdId;
+	short int useCount;
+} yaffsfs_Handle;
 
 static yaffsfs_Inode yaffsfs_inode[YAFFSFS_N_HANDLES];
+static yaffsfs_FileDes yaffsfs_fd[YAFFSFS_N_HANDLES];
 static yaffsfs_Handle yaffsfs_handle[YAFFSFS_N_HANDLES];
+
 static int yaffsfs_handlesInitialised;
 
+
+unsigned yaffs_set_trace(unsigned  tm)
+{
+	yaffs_trace_mask = tm;
+	return yaffs_trace_mask;
+}
+
+unsigned yaffs_get_trace(void)
+{
+	return yaffs_trace_mask;
+}
+
 /*
  * yaffsfs_InitHandle
  * Inilitalise handle management on start-up.
@@ -79,32 +113,46 @@ static void yaffsfs_InitHandles(void)
                 return;
 
 	memset(yaffsfs_inode,0,sizeof(yaffsfs_inode));
+	memset(yaffsfs_fd,0,sizeof(yaffsfs_fd));
 	memset(yaffsfs_handle,0,sizeof(yaffsfs_handle));
+
+	for(i = 0; i < YAFFSFS_N_HANDLES; i++)
+		yaffsfs_fd[i].inodeId = -1;
 	for(i = 0; i < YAFFSFS_N_HANDLES; i++)
-		yaffsfs_handle[i].inodeId = -1;
+		yaffsfs_handle[i].fdId = -1;
 }
 
-yaffsfs_Handle *yaffsfs_GetHandlePointer(int h)
+static yaffsfs_Handle *yaffsfs_HandleToPointer(int h)
 {
-	if(h < 0 || h >= YAFFSFS_N_HANDLES)
-		return NULL;
+	if(h >= 0 && h < YAFFSFS_N_HANDLES)
+		return &yaffsfs_handle[h];
+	return NULL;
+}
 
-	return &yaffsfs_handle[h];
+static yaffsfs_FileDes *yaffsfs_HandleToFileDes(int handle)
+{
+	yaffsfs_Handle *h = yaffsfs_HandleToPointer(handle);
+
+	if(h && h->useCount > 0 && h->fdId >= 0 && h->fdId < YAFFSFS_N_HANDLES)
+		return  &yaffsfs_fd[h->fdId];
+
+	return NULL;
 }
 
-yaffsfs_Inode *yaffsfs_GetInodePointer(int handle)
+static yaffsfs_Inode *yaffsfs_HandleToInode(int handle)
 {
-	yaffsfs_Handle *h = yaffsfs_GetHandlePointer(handle);
+	yaffsfs_FileDes *fd = yaffsfs_HandleToFileDes(handle);
 
-	if(h && h->useCount > 0 && h->inodeId >= 0 && h->inodeId < YAFFSFS_N_HANDLES)
-		return  &yaffsfs_inode[h->inodeId];
+	if(fd && fd->handleCount > 0 &&
+		fd->inodeId >= 0 && fd->inodeId < YAFFSFS_N_HANDLES)
+		return  &yaffsfs_inode[fd->inodeId];
 
 	return NULL;
 }
 
-yaffs_Object *yaffsfs_GetHandleObject(int handle)
+static struct yaffs_obj *yaffsfs_HandleToObject(int handle)
 {
-	yaffsfs_Inode *in = yaffsfs_GetInodePointer(handle);
+	yaffsfs_Inode *in = yaffsfs_HandleToInode(handle);
 
 	if(in)
 		return in->iObj;
@@ -117,13 +165,13 @@ yaffs_Object *yaffsfs_GetHandleObject(int handle)
  * Find the inode entry for an object, if it exists.
  */
 
-static int yaffsfs_FindInodeIdForObject(yaffs_Object *obj)
+static int yaffsfs_FindInodeIdForObject(struct yaffs_obj *obj)
 {
 	int i;
 	int ret = -1;
-	
+
 	if(obj)
-		obj = yaffs_GetEquivalentObject(obj);
+		obj = yaffs_get_equivalent_obj(obj);
 
 	/* Look for it in open inode table*/
 	for(i = 0; i < YAFFSFS_N_HANDLES && ret < 0; i++){
@@ -137,14 +185,14 @@ static int yaffsfs_FindInodeIdForObject(yaffs_Object *obj)
  * yaffsfs_GetInodeIdForObject
  * Grab an inode entry when opening a new inode.
  */
-static int yaffsfs_GetInodeIdForObject(yaffs_Object *obj)
+static int yaffsfs_GetInodeIdForObject(struct yaffs_obj *obj)
 {
 	int i;
 	int ret;
 	yaffsfs_Inode *in = NULL;
-	
+
 	if(obj)
-		obj = yaffs_GetEquivalentObject(obj);
+		obj = yaffs_get_equivalent_obj(obj);
 
         ret = yaffsfs_FindInodeIdForObject(obj);
 
@@ -160,13 +208,13 @@ static int yaffsfs_GetInodeIdForObject(yaffs_Object *obj)
 		in->iObj = obj;
 		in->count++;
 	}
-	
-	
+
+
 	return ret;
 }
 
 
-static int yaffsfs_CountHandles(yaffs_Object *obj)
+static int yaffsfs_CountHandles(struct yaffs_obj *obj)
 {
 	int i = yaffsfs_FindInodeIdForObject(obj);
 
@@ -178,14 +226,14 @@ static int yaffsfs_CountHandles(yaffs_Object *obj)
 
 static void yaffsfs_ReleaseInode(yaffsfs_Inode *in)
 {
-	yaffs_Object *obj;
-	
+	struct yaffs_obj *obj;
+
 	obj = in->iObj;
 
 	if(obj->unlinked)
-		yaffs_DeleteObject(obj);
-	
-	obj->myInode = NULL;
+		yaffs_del_obj(obj);
+
+	obj->my_inode = NULL;
 	in->iObj = NULL;
 
 }
@@ -195,85 +243,164 @@ static void yaffsfs_PutInode(int inodeId)
 	if(inodeId >= 0 && inodeId < YAFFSFS_N_HANDLES){
 		yaffsfs_Inode *in = & yaffsfs_inode[inodeId];
 		in->count--;
-		if(in->count <= 0)
+		if(in->count <= 0){
 			yaffsfs_ReleaseInode(in);
-	}	
+			in->count = 0;
+		}
+	}
 }
 
 
-/*
- * yaffsfs_GetHandle
- * Grab a handle (when opening a file)
- */
 
-static int yaffsfs_GetNewHandle(void)
+static int yaffsfs_NewHandle(yaffsfs_Handle **hptr)
 {
 	int i;
 	yaffsfs_Handle *h;
 
 	for(i = 0; i < YAFFSFS_N_HANDLES; i++){
-		h = yaffsfs_GetHandlePointer(i);
-		if(!h){
-			/* todo bug: should never happen */
-		}
+		h = &yaffsfs_handle[i];
 		if(h->useCount < 1){
 			memset(h,0,sizeof(yaffsfs_Handle));
-			h->inodeId=-1;
+			h->fdId=-1;
 			h->useCount=1;
+			if(hptr)
+				*hptr = h;
 			return i;
 		}
 	}
 	return -1;
 }
 
+static int yaffsfs_NewHandleAndFileDes(void)
+{
+	int i;
+	yaffsfs_FileDes *fd;
+	yaffsfs_Handle  *h = NULL;
+	int handle = yaffsfs_NewHandle(&h);
+
+	if(handle < 0)
+		return -1;
+
+	for(i = 0; i < YAFFSFS_N_HANDLES; i++){
+		fd = &yaffsfs_fd[i];
+		if(fd->handleCount < 1){
+			memset(fd,0,sizeof(yaffsfs_FileDes));
+			fd->inodeId=-1;
+			fd->handleCount=1;
+			h->fdId = i;
+			return handle;
+		}
+	}
+
+	/* Dump the handle because we could not get a fd */
+	h->useCount = 0;
+	return -1;
+}
+
 /*
- * yaffs_GetHandle
+ * yaffs_get_handle
  * Increase use of handle when reading/writing a file
+ * Also gets the file descriptor.
  */
+
 static int yaffsfs_GetHandle(int handle)
 {
-	yaffsfs_Handle *h = yaffsfs_GetHandlePointer(handle);
+	yaffsfs_Handle *h = yaffsfs_HandleToPointer(handle);
 
-	if(h && h->useCount > 0){	
+	if(h && h->useCount > 0){
 		h->useCount++;
+		return 0;
 	}
-	return 0;
+	return -1;
 }
 
 /*
- * yaffs_PutHandle
+ * yaffs_put_handle
  * Let go of a handle when closing a file or aborting an open or
  * ending a read or write.
  */
+
+static int yaffsfs_PutFileDes(int fdId)
+{
+	yaffsfs_FileDes *fd;
+
+	if(fdId >= 0 && fdId < YAFFSFS_N_HANDLES){
+		fd = &yaffsfs_fd[fdId];
+		fd->handleCount--;
+		if(fd->handleCount < 1){
+			if(fd->inodeId >= 0){
+				yaffsfs_PutInode(fd->inodeId);
+				fd->inodeId = -1;
+			}
+		}
+	}
+	return 0;
+}
 static int yaffsfs_PutHandle(int handle)
 {
-	yaffsfs_Handle *h = yaffsfs_GetHandlePointer(handle);
+	yaffsfs_Handle *h = yaffsfs_HandleToPointer(handle);
 
-	if(h && h->useCount > 0){	
+	if(h && h->useCount > 0){
 		h->useCount--;
 		if(h->useCount < 1){
-			if(h->inodeId >= 0){
-				yaffsfs_PutInode(h->inodeId);
-				h->inodeId = -1;
-			}
+			yaffsfs_PutFileDes(h->fdId);
+			h->fdId = -1;
 		}
 	}
+
 	return 0;
 }
 
+static void yaffsfs_BreakDeviceHandles(struct yaffs_dev *dev)
+{
+	yaffsfs_FileDes *fd;
+	yaffsfs_Handle *h;
+	struct yaffs_obj *obj;
+	int i;
+	for(i = 0; i < YAFFSFS_N_HANDLES; i++){
+		h = yaffsfs_HandleToPointer(i);
+		fd = yaffsfs_HandleToFileDes(i);
+		obj = yaffsfs_HandleToObject(i);
+		if(h && h->useCount > 0){
+			h->useCount = 0;
+			h->fdId = 0;
+		}
+		if(fd && fd->handleCount>0 && obj && obj->my_dev == dev){
+
+			fd->handleCount = 0;
+			yaffsfs_PutInode(fd->inodeId);
+			fd->inodeId = -1;
+		}
+	}
+}
+
 
 
 
 /*
- *  Stuff to search for a directory from a path
+ *  Stuff to handle names.
  */
+#ifdef CONFIG_YAFFS_CASE_INSENSITIVE
+ 
+static int yaffs_toupper(YCHAR a)
+{
+	if(a >= 'a' && a <= 'z')
+		return (a - 'a') + 'A';
+	else
+		return a;
+}
 
-
+int yaffsfs_Match(YCHAR a, YCHAR b)
+{
+	return (yaffs_toupper(a) == yaffs_toupper(b));
+}
+#else
 int yaffsfs_Match(YCHAR a, YCHAR b)
 {
 	/* case sensitive */
 	return (a == b);
 }
+#endif
 
 int yaffsfs_IsPathDivider(YCHAR ch)
 {
@@ -288,24 +415,75 @@ int yaffsfs_IsPathDivider(YCHAR ch)
 	return 0;
 }
 
+int yaffsfs_CheckNameLength(const char *name)
+{
+	int retVal = 0;
 
+	int nameLength = yaffs_strnlen(name,YAFFS_MAX_NAME_LENGTH+1);
+
+	if(nameLength == 0){
+		yaffsfs_SetError(-ENOENT);
+		retVal = -1;
+	} else if (nameLength > YAFFS_MAX_NAME_LENGTH){
+		yaffsfs_SetError(-ENAMETOOLONG);
+		retVal = -1;
+	}
+
+	return retVal;
+}
 
-YLIST_HEAD(yaffsfs_deviceList);
+
+static int yaffsfs_alt_dir_path(const YCHAR *path, YCHAR **ret_path)
+{
+	YCHAR *alt_path = NULL;
+	int path_length;
+	int i;
+
+	/*
+	 * We don't have a definition for max path length.
+	 * We will use 3 * max name length instead.
+	 */
+	*ret_path = NULL;
+	path_length = yaffs_strnlen(path,(YAFFS_MAX_NAME_LENGTH+1)*3 +1);
+
+	/* If the last character is a path divider, then we need to
+	 * trim it back so that the name look-up works properly.
+	 * eg. /foo/new_dir/ -> /foo/newdir
+	 * Curveball: Need to handle multiple path dividers:
+	 * eg. /foof/sdfse///// -> /foo/sdfse
+	 */
+	if(path_length > 0 &&
+		yaffsfs_IsPathDivider(path[path_length-1])){
+		alt_path = kmalloc(path_length + 1, 0);
+		if(!alt_path)
+			return -1;
+		yaffs_strcpy(alt_path, path);
+		for(i = path_length-1;
+			i >= 0 && yaffsfs_IsPathDivider(alt_path[i]);
+			i--)
+			alt_path[i] = (YCHAR) 0;
+	}
+	*ret_path = alt_path;
+	return 0;
+}
+
+
+LIST_HEAD(yaffsfs_deviceList);
 
 /*
  * yaffsfs_FindDevice
  * yaffsfs_FindRoot
- * Scan the configuration list to find the root.
+ * Scan the configuration list to find the device
  * Curveballs: Should match paths that end in '/' too
  * Curveball2 Might have "/x/ and "/x/y". Need to return the longest match
  */
-static yaffs_Device *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPath)
+static struct yaffs_dev *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPath)
 {
-	struct ylist_head *cfg;
+	struct list_head *cfg;
 	const YCHAR *leftOver;
 	const YCHAR *p;
-	yaffs_Device *retval = NULL;
-	yaffs_Device *dev = NULL;
+	struct yaffs_dev *retval = NULL;
+	struct yaffs_dev *dev = NULL;
 	int thisMatchLength;
 	int longestMatch = -1;
 	int matching;
@@ -315,8 +493,8 @@ static yaffs_Device *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPath)
 	 * 1) Actually matches a prefix (ie /a amd /abc will not match
 	 * 2) Matches the longest.
 	 */
-	ylist_for_each(cfg, &yaffsfs_deviceList){
-		dev = ylist_entry(cfg, yaffs_Device, devList);
+	list_for_each(cfg, &yaffsfs_deviceList){
+		dev = list_entry(cfg, struct yaffs_dev, dev_list);
 		leftOver = path;
 		p = dev->param.name;
 		thisMatchLength = 0;
@@ -370,76 +548,63 @@ static yaffs_Device *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPath)
 	return retval;
 }
 
-#if 0
-static yaffs_Device *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPath)
+static int yaffsfs_CheckPath(const YCHAR *path)
 {
-	yaffsfs_DeviceConfiguration *cfg = yaffsfs_configurationList;
-	const YCHAR *leftOver;
-	const YCHAR *p;
-	yaffs_Device *retval = NULL;
-	int thisMatchLength;
-	int longestMatch = -1;
-
-	/*
-	 * Check all configs, choose the one that:
-	 * 1) Actually matches a prefix (ie /a amd /abc will not match
-	 * 2) Matches the longest.
-	 */
-	while(cfg && cfg->prefix && cfg->dev){
-		leftOver = path;
-		p = cfg->prefix;
-		thisMatchLength = 0;
-
-		while(*p &&  /* unmatched part of prefix */
-		      !(yaffsfs_IsPathDivider(*p) && (p[1] == 0)) &&
-		      *leftOver && yaffsfs_Match(*p,*leftOver)){
-			p++;
-			leftOver++;
-			thisMatchLength++;
-		}
+	int n=0;
+	int divs=0;
+	while(*path && n < YAFFS_MAX_NAME_LENGTH && divs < 100){
+		if(yaffsfs_IsPathDivider(*path)){
+			n=0;
+			divs++;
+		} else
+			n++;
+		path++;
+	}
 
+	return (*path) ? -1 : 0;
+}
 
-		if((!*p || (yaffsfs_IsPathDivider(*p) && (p[1] == 0))) &&  /* end of prefix */
-		   (!*leftOver || yaffsfs_IsPathDivider(*leftOver)) && /* no more in this path name part */
-		   (thisMatchLength > longestMatch)){
-			/* Matched prefix */
-			*restOfPath = (YCHAR *)leftOver;
-			retval = cfg->dev;
-			longestMatch = thisMatchLength;
-		}
-		cfg++;
-	}
-	return retval;
+/* FindMountPoint only returns a dev entry if the path is a mount point */
+static struct yaffs_dev *yaffsfs_FindMountPoint(const YCHAR *path)
+{
+	struct yaffs_dev *dev;
+	YCHAR *restOfPath=NULL;
+	dev = yaffsfs_FindDevice(path,&restOfPath);
+	if(dev && restOfPath && *restOfPath)
+		dev = NULL;
+	return dev;
 }
-#endif
 
-static yaffs_Object *yaffsfs_FindRoot(const YCHAR *path, YCHAR **restOfPath)
+static struct yaffs_obj *yaffsfs_FindRoot(const YCHAR *path, YCHAR **restOfPath)
 {
 
-	yaffs_Device *dev;
+	struct yaffs_dev *dev;
 
 	dev= yaffsfs_FindDevice(path,restOfPath);
-	if(dev && dev->isMounted){
-		return dev->rootDir;
+	if(dev && dev->is_mounted){
+		return dev->root_dir;
 	}
 	return NULL;
 }
 
-static yaffs_Object *yaffsfs_FollowLink(yaffs_Object *obj,int symDepth)
+static struct yaffs_obj *yaffsfs_FollowLink(struct yaffs_obj *obj,
+					int symDepth, int *loop)
 {
 
 	if(obj)
-		obj = yaffs_GetEquivalentObject(obj);
+		obj = yaffs_get_equivalent_obj(obj);
 
-	while(obj && obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK){
-		YCHAR *alias = obj->variant.symLinkVariant.alias;
+	while(obj && obj->variant_type == YAFFS_OBJECT_TYPE_SYMLINK){
+		YCHAR *alias = obj->variant.symlink_variant.alias;
 
 		if(yaffsfs_IsPathDivider(*alias))
 			/* Starts with a /, need to scan from root up */
-			obj = yaffsfs_FindObject(NULL,alias,symDepth++,1);
+			obj = yaffsfs_FindObject(NULL,alias,symDepth++,
+						1,NULL,NULL,loop);
 		else
 			/* Relative to here, so use the parent of the symlink as a start */
-			obj = yaffsfs_FindObject(obj->parent,alias,symDepth++,1);
+			obj = yaffsfs_FindObject(obj->parent,alias,symDepth++,
+						1,NULL,NULL,loop);
 	}
 	return obj;
 }
@@ -451,16 +616,20 @@ static yaffs_Object *yaffsfs_FollowLink(yaffs_Object *obj,int symDepth)
  *
  * eg. "/data/xx/ff" --> puts name="ff" and returns the directory "/data/xx"
  */
-static yaffs_Object *yaffsfs_DoFindDirectory(yaffs_Object *startDir,
-				const YCHAR *path, YCHAR **name, int symDepth)
+static struct yaffs_obj *yaffsfs_DoFindDirectory(struct yaffs_obj *startDir,
+				const YCHAR *path, YCHAR **name, int symDepth,
+				int *notDir,int *loop)
 {
-	yaffs_Object *dir;
+	struct yaffs_obj *dir;
 	YCHAR *restOfPath;
 	YCHAR str[YAFFS_MAX_NAME_LENGTH+1];
 	int i;
 
-	if(symDepth > YAFFSFS_MAX_SYMLINK_DEREFERENCES)
+	if(symDepth > YAFFSFS_MAX_SYMLINK_DEREFERENCES){
+		if(loop)
+			*loop = 1;
 		return NULL;
+	}
 
 	if(startDir){
 		dir = startDir;
@@ -469,6 +638,7 @@ static yaffs_Object *yaffsfs_DoFindDirectory(yaffs_Object *startDir,
 	else
 		dir = yaffsfs_FindRoot(path,&restOfPath);
 
+
 	while(dir){
 		/*
 		 * parse off /.
@@ -494,20 +664,22 @@ static yaffs_Object *yaffsfs_DoFindDirectory(yaffs_Object *startDir,
 			/* got to the end of the string */
 			return dir;
 		else{
-			if(yaffs_strcmp(str,_Y(".")) == 0)
-			{
+			if(yaffs_strcmp(str,_Y(".")) == 0){
 				/* Do nothing */
-			}
-			else if(yaffs_strcmp(str,_Y("..")) == 0)
+			} else if(yaffs_strcmp(str,_Y("..")) == 0) {
 				dir = dir->parent;
-			else{
-				dir = yaffs_FindObjectByName(dir,str);
-
-				dir = yaffsfs_FollowLink(dir,symDepth);
+			} else{
+				dir = yaffs_find_by_name(dir,str);
 
+				dir = yaffsfs_FollowLink(dir,symDepth,loop);
 
-				if(dir && dir->variantType != YAFFS_OBJECT_TYPE_DIRECTORY)
+				if(dir && dir->variant_type !=
+					YAFFS_OBJECT_TYPE_DIRECTORY){
+					if(notDir)
+						*notDir = 1;
 					dir = NULL;
+				}
+
 			}
 		}
 	}
@@ -515,80 +687,117 @@ static yaffs_Object *yaffsfs_DoFindDirectory(yaffs_Object *startDir,
 	return NULL;
 }
 
-static yaffs_Object *yaffsfs_FindDirectory(yaffs_Object *relativeDirectory,
-					const YCHAR *path,YCHAR **name,int symDepth)
+static struct yaffs_obj *yaffsfs_FindDirectory(struct yaffs_obj *relDir,
+					const YCHAR *path,
+					YCHAR **name,
+					int symDepth,
+					int *notDir,
+					int *loop)
 {
-	return yaffsfs_DoFindDirectory(relativeDirectory,path,name,symDepth);
+	return yaffsfs_DoFindDirectory(relDir,path,name,symDepth,notDir,loop);
 }
 
 /*
  * yaffsfs_FindObject turns a path for an existing object into the object
  */
-static yaffs_Object *yaffsfs_FindObject(yaffs_Object *relativeDirectory, const YCHAR *path,int symDepth,int getEquiv)
+static struct yaffs_obj *yaffsfs_FindObject(struct yaffs_obj *relDir,
+			const YCHAR *path,int symDepth, int getEquiv,
+			struct yaffs_obj **dirOut, int *notDir,int *loop)
 {
-	yaffs_Object *dir;
-	yaffs_Object *obj;
+	struct yaffs_obj *dir;
+	struct yaffs_obj *obj;
 	YCHAR *name;
 
-	dir = yaffsfs_FindDirectory(relativeDirectory,path,&name,symDepth);
+	dir = yaffsfs_FindDirectory(relDir,path,&name,symDepth,notDir,loop);
+
+	if(dirOut)
+		*dirOut =  dir;
 
 	if(dir && *name)
-		obj = yaffs_FindObjectByName(dir,name);
+		obj = yaffs_find_by_name(dir,name);
 	else
 		obj = dir;
+
 	if(getEquiv)
-		obj = yaffs_GetEquivalentObject(obj);
+		obj = yaffs_get_equivalent_obj(obj);
 
 	return obj;
 }
 
 
-int yaffs_dup(int fd)
+/*************************************************************************
+ *	Start of yaffsfs visible functions.
+ *************************************************************************/
+
+int yaffs_dup(int handle)
 {
-	int newHandle = -1;
-	yaffsfs_Handle *oldPtr = NULL;
-	yaffsfs_Handle *newPtr = NULL;
+	int newHandleNumber = -1;
+	yaffsfs_FileDes *existingFD = NULL;
+	yaffsfs_Handle *existingHandle = NULL;
+	yaffsfs_Handle *newHandle = NULL;
 
 	yaffsfs_Lock();
-
-	oldPtr = yaffsfs_GetHandlePointer(fd);
-	if(oldPtr && oldPtr->useCount > 0)
-		newHandle = yaffsfs_GetNewHandle();
-	if(newHandle >= 0)
-		newPtr = yaffsfs_GetHandlePointer(newHandle);
-
-	if(newPtr){
-		*newPtr = *oldPtr;
-		return newHandle;
+	existingHandle = yaffsfs_HandleToPointer(handle);
+	existingFD = yaffsfs_HandleToFileDes(handle);
+	if(existingFD)
+		newHandleNumber = yaffsfs_NewHandle(&newHandle);
+	if(newHandle){
+		newHandle->fdId = existingHandle->fdId;
+		existingFD->handleCount++;
 	}
 
-	if(!oldPtr)
+	yaffsfs_Unlock();
+
+	if(!existingFD)
 		yaffsfs_SetError(-EBADF);
-	else
+	else if (!newHandle)
 		yaffsfs_SetError(-ENOMEM);
 
-	return -1;
+	return newHandleNumber;
 
 }
 
+static int yaffsfs_TooManyObjects(struct yaffs_dev *dev)
+{
+	int current_objects = dev->n_obj - dev->n_deleted_files;
+
+	if(dev->param.max_objects && current_objects > dev->param.max_objects)
+		return 1;
+	else
+		return 0;
+}
+
 int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing)
 {
-	yaffs_Object *obj = NULL;
-	yaffs_Object *dir = NULL;
+	struct yaffs_obj *obj = NULL;
+	struct yaffs_obj *dir = NULL;
 	YCHAR *name;
 	int handle = -1;
-	yaffsfs_Handle *yh = NULL;
+	yaffsfs_FileDes *fd = NULL;
 	int openDenied = 0;
 	int symDepth = 0;
 	int errorReported = 0;
-	__u8 shareRead = (sharing & YAFFS_SHARE_READ) ?  1 : 0;
-	__u8 shareWrite = (sharing & YAFFS_SHARE_WRITE) ? 1 : 0;
-	__u8 sharedReadAllowed;
-	__u8 sharedWriteAllowed;
-	__u8 alreadyReading;
-	__u8 alreadyWriting;
-	__u8 readRequested;
-	__u8 writeRequested;
+	int rwflags = oflag & ( O_RDWR | O_RDONLY | O_WRONLY);
+	u8 shareRead = (sharing & YAFFS_SHARE_READ) ?  1 : 0;
+	u8 shareWrite = (sharing & YAFFS_SHARE_WRITE) ? 1 : 0;
+	u8 sharedReadAllowed;
+	u8 sharedWriteAllowed;
+	u8 alreadyReading;
+	u8 alreadyWriting;
+	u8 readRequested;
+	u8 writeRequested;
+	int notDir = 0;
+	int loop = 0;
+
+	if(!path) {
+		yaffsfs_SetError(-EFAULT);
+		return -1;
+	}
+
+	if(yaffsfs_CheckPath(path) < 0){
+		yaffsfs_SetError(-ENAMETOOLONG);
+		return -1;
+	}
 
 	/* O_EXCL only has meaning if O_CREAT is specified */
 	if(!(oflag & O_CREAT))
@@ -600,31 +809,39 @@ int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing)
 
 	/* Todo: Are there any more flag combos to sanitise ? */
 
+	/* Figure out if reading or writing is requested */
+
+	readRequested = (rwflags == O_RDWR || rwflags == O_RDONLY) ? 1 : 0;
+	writeRequested = (rwflags == O_RDWR || rwflags == O_WRONLY) ? 1 : 0;
 
 	yaffsfs_Lock();
 
-	handle = yaffsfs_GetNewHandle();
+	handle = yaffsfs_NewHandleAndFileDes();
 
-	if(handle >= 0){
+	if(handle < 0){
+		yaffsfs_SetError(-ENFILE);
+		errorReported = 1;
+	} else {
 
-		yh = yaffsfs_GetHandlePointer(handle);
+		fd = yaffsfs_HandleToFileDes(handle);
 
 		/* try to find the exisiting object */
-		obj = yaffsfs_FindObject(NULL,path,0,1);
+		obj = yaffsfs_FindObject(NULL,path,0,1,NULL,NULL,NULL);
 
-		obj = yaffsfs_FollowLink(obj,symDepth++);
+		obj = yaffsfs_FollowLink(obj,symDepth++,&loop);
 
 		if(obj &&
-			obj->variantType != YAFFS_OBJECT_TYPE_FILE &&
-			obj->variantType != YAFFS_OBJECT_TYPE_DIRECTORY)
+			obj->variant_type != YAFFS_OBJECT_TYPE_FILE &&
+			obj->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY)
 			obj = NULL;
 
+
 		if(obj){
 
 			/* The file already exists or it might be a directory */
 
 			/* If it is a directory then we can't open it as a file */
-			if(obj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY){
+			if(obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY){
 				openDenied = 1;
 				yaffsfs_SetError(-EISDIR);
 				errorReported = 1;
@@ -633,53 +850,60 @@ int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing)
 			/* Open should fail if O_CREAT and O_EXCL are specified since
 			 * the file exists
 			 */
-			if((oflag & O_EXCL) && (oflag & O_CREAT)){
+			if(!errorReported && (oflag & O_EXCL) && (oflag & O_CREAT)){
 				openDenied = 1;
 				yaffsfs_SetError(-EEXIST);
 				errorReported = 1;
 			}
 
 			/* Check file permissions */
-			if( (oflag & (O_RDWR | O_WRONLY)) == 0 &&     /* ie O_RDONLY */
-			   !(obj->yst_mode & S_IREAD))
+			if( readRequested && !(obj->yst_mode & S_IREAD))
 				openDenied = 1;
 
-			if( (oflag & O_RDWR) &&
-			   !(obj->yst_mode & S_IREAD))
+			if( writeRequested && !(obj->yst_mode & S_IWRITE))
 				openDenied = 1;
 
-			if( (oflag & (O_RDWR | O_WRONLY)) &&
-			   !(obj->yst_mode & S_IWRITE))
+			if( !errorReported && writeRequested &&
+				obj->my_dev->read_only){
 				openDenied = 1;
+				yaffsfs_SetError(-EROFS);
+				errorReported = 1;
+			}
+
+			if(openDenied && !errorReported ) {
+				/* Error if the file exists but permissions are refused. */
+				yaffsfs_SetError(-EACCES);
+				errorReported = 1;
+			}
 
 			/* Check sharing of an existing object. */
-			{
-				yaffsfs_Handle *hx;
+			if(!openDenied){
+				yaffsfs_FileDes *fdx;
 				int i;
+
 				sharedReadAllowed = 1;
 				sharedWriteAllowed = 1;
 				alreadyReading = 0;
 				alreadyWriting = 0;
 				for( i = 0; i < YAFFSFS_N_HANDLES; i++){
-					hx = &yaffsfs_handle[i];
-					if(hx->useCount > 0 &&
-						hx->inodeId >= 0 &&
-						yaffsfs_inode[hx->inodeId].iObj == obj){
-						if(!hx->shareRead)
+					fdx = &yaffsfs_fd[i];
+					if(fdx->handleCount > 0 &&
+						fdx->inodeId >= 0 &&
+						yaffsfs_inode[fdx->inodeId].iObj == obj){
+						if(!fdx->shareRead)
 							sharedReadAllowed = 0;
-						if(!hx->shareWrite)
+						if(!fdx->shareWrite)
 							sharedWriteAllowed = 0;
-						if(hx->reading)
+						if(fdx->reading)
 							alreadyReading = 1;
-						if(hx->writing)
-							alreadyWriting = 0;
+						if(fdx->writing)
+							alreadyWriting = 1;
 					}
 				}
 
-				readRequested = (oflag & (O_RDWR | O_RDONLY)) ? 1 : 0;
-				writeRequested = (oflag & (O_RDWR | O_WRONLY)) ? 1 : 0;
 
-				if((!sharedReadAllowed && readRequested)|| 
+
+				if((!sharedReadAllowed && readRequested)||
 					(!shareRead  && alreadyReading) ||
 					(!sharedWriteAllowed && writeRequested) ||
 					(!shareWrite && alreadyWriting)){
@@ -689,49 +913,75 @@ int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing)
 				}
 			}
 
-		} else if((oflag & O_CREAT)) {
-			/* Let's see if we can create this file */
-			dir = yaffsfs_FindDirectory(NULL,path,&name,0);
-			if(dir  && dir->myDev->readOnly){
-				yaffsfs_SetError(-EINVAL);
-				errorReported = 1;
-			} else if(dir)
-				obj = yaffs_MknodFile(dir,name,mode,0,0);
-			else {
+		}
+
+		/* If we could not open an existing object, then let's see if
+		 * the directory exists. If not, error.
+		 */
+		if(!obj && !errorReported){
+			dir = yaffsfs_FindDirectory(NULL,path,&name,0,&notDir,&loop);
+			if(!dir && notDir){
 				yaffsfs_SetError(-ENOTDIR);
 				errorReported = 1;
+			} else if(loop){
+				yaffsfs_SetError(-ELOOP);
+				errorReported = 1;
+			} else	if(!dir){
+				yaffsfs_SetError(-ENOENT);
+				errorReported = 1;
 			}
 		}
 
+		if(!obj && dir && !errorReported && (oflag & O_CREAT)) {
+			/* Let's see if we can create this file if it does not exist. */
+			if(dir->my_dev->read_only){
+				yaffsfs_SetError(-EROFS);
+				errorReported = 1;
+			} else if(yaffsfs_TooManyObjects(dir->my_dev)) {
+				yaffsfs_SetError(-ENFILE);
+				errorReported = 1;
+			} else
+				obj = yaffs_create_file(dir,name,mode,0,0);
+
+			if(!obj && !errorReported){
+				yaffsfs_SetError(-ENOSPC);
+				errorReported = 1;
+			}
+		}
+
+		if(!obj && dir && !errorReported && !(oflag & O_CREAT)) {
+			/* Error if the file does not exist and CREAT is not set. */
+			yaffsfs_SetError(-ENOENT);
+			errorReported = 1;
+		}
+
 		if(obj && !openDenied) {
 			int inodeId = yaffsfs_GetInodeIdForObject(obj);
 
 			if(inodeId<0) {
 				/*
 				 * Todo: Fix any problem if inodes run out, though that
-				 * can't happen if the number of inode items >= number of handles. 
+				 * can't happen if the number of inode items >= number of handles.
 				 */
 			}
-			
-			yh->inodeId = inodeId;
-			yh->reading = (oflag & (O_RDONLY | O_RDWR)) ? 1 : 0;
-			yh->writing = (oflag & (O_WRONLY | O_RDWR)) ? 1 : 0;
-			yh->append =  (oflag & O_APPEND) ? 1 : 0;
-			yh->position = 0;
-			yh->shareRead = shareRead;
-			yh->shareWrite = shareWrite;
+
+			fd->inodeId = inodeId;
+			fd->reading = readRequested;
+			fd->writing = writeRequested;
+			fd->append =  (oflag & O_APPEND) ? 1 : 0;
+			fd->position = 0;
+			fd->shareRead = shareRead;
+			fd->shareWrite = shareWrite;
 
 			/* Hook inode to object */
-                        obj->myInode = (void*) &yaffsfs_inode[inodeId];
+                        obj->my_inode = (void*) &yaffsfs_inode[inodeId];
 
-                        if((oflag & O_TRUNC) && yh->writing)
-                                yaffs_ResizeFile(obj,0);
+                        if((oflag & O_TRUNC) && fd->writing)
+                                yaffs_resize_file(obj,0);
 		} else {
 			yaffsfs_PutHandle(handle);
-			if(!errorReported) {
-				yaffsfs_SetError(-EACCES);
-				errorReported = 1;
-			}
+			if(!errorReported)
+				yaffsfs_SetError(0); /* Problem */
 			handle = -1;
 		}
 	}
@@ -743,25 +993,26 @@ int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing)
 
 int yaffs_open(const YCHAR *path, int oflag, int mode)
 {
-	return yaffs_open_sharing(path, oflag, mode, YAFFS_SHARE_READ | YAFFS_SHARE_WRITE);
+	return yaffs_open_sharing(path, oflag, mode,
+			YAFFS_SHARE_READ | YAFFS_SHARE_WRITE);
 }
 
-int yaffs_Dofsync(int fd,int datasync)
+int yaffs_Dofsync(int handle,int datasync)
 {
-	yaffsfs_Handle *h = NULL;
-	int retVal = 0;
+	int retVal = -1;
+	struct yaffs_obj *obj;
 
 	yaffsfs_Lock();
 
-	h = yaffsfs_GetHandlePointer(fd);
+	obj = yaffsfs_HandleToObject(handle);
 
-	if(h && h->useCount > 0)
-		/* flush the file */
-		yaffs_FlushFile(yaffsfs_inode[h->inodeId].iObj,1,datasync);
-	else {
-		/* bad handle */
+	if(!obj)
 		yaffsfs_SetError(-EBADF);
-		retVal = -1;
+	else if(obj->my_dev->read_only)
+		yaffsfs_SetError(-EROFS);
+	else {
+		yaffs_flush_file(obj,1,datasync);
+		retVal = 0;
 	}
 
 	yaffsfs_Unlock();
@@ -769,39 +1020,39 @@ int yaffs_Dofsync(int fd,int datasync)
 	return retVal;
 }
 
-int yaffs_fsync(int fd)
+int yaffs_fsync(int handle)
 {
-	return yaffs_Dofsync(fd,0);
+	return yaffs_Dofsync(handle,0);
 }
 
-int yaffs_flush(int fd)
+int yaffs_flush(int handle)
 {
-	return yaffs_fsync(fd);
+	return yaffs_fsync(handle);
 }
 
-int yaffs_fdatasync(int fd)
+int yaffs_fdatasync(int handle)
 {
-	return yaffs_Dofsync(fd,1);
+	return yaffs_Dofsync(handle,1);
 }
 
-int yaffs_close(int fd)
+int yaffs_close(int handle)
 {
 	yaffsfs_Handle *h = NULL;
-	int retVal = 0;
+	struct yaffs_obj *obj = NULL;
+	int retVal = -1;
 
 	yaffsfs_Lock();
 
-	h = yaffsfs_GetHandlePointer(fd);
+	h = yaffsfs_HandleToPointer(handle);
+	obj = yaffsfs_HandleToObject(handle);
 
-	if(h && h->useCount > 0) {
+	if(!h  || !obj)
+		yaffsfs_SetError(-EBADF);
+	else {
 		/* clean up */
-		yaffs_FlushFile(yaffsfs_inode[h->inodeId].iObj,1,0);
-		yaffsfs_PutHandle(fd);
+		yaffs_flush_file(obj,1,0);
+		yaffsfs_PutHandle(handle);
 		retVal = 0;
-	} else {
-		/* bad handle */
-		yaffsfs_SetError(-EBADF);
-		retVal = -1;
 	}
 
 	yaffsfs_Unlock();
@@ -811,36 +1062,49 @@ int yaffs_close(int fd)
 
 
 
-int yaffsfs_do_read(int fd, void *vbuf, unsigned int nbyte, int isPread, int offset)
+int yaffsfs_do_read(int handle, void *vbuf, unsigned int nbyte, int isPread, loff_t offset)
 {
-	yaffsfs_Handle *h = NULL;
-	yaffs_Object *obj = NULL;
-	int pos = 0;
-	int startPos = 0;
+	yaffsfs_FileDes *fd = NULL;
+	struct yaffs_obj *obj = NULL;
+	loff_t pos = 0;
+	loff_t startPos = 0;
+	loff_t endPos = 0;
 	int nRead = 0;
 	int nToRead = 0;
 	int totalRead = 0;
-	unsigned int maxRead;
-	__u8 *buf = (__u8 *)vbuf;
+	loff_t maxRead;
+	u8 *buf = (u8 *)vbuf;
+
+	if(!vbuf){
+		yaffsfs_SetError(-EFAULT);
+		return -1;
+	}
 
 	yaffsfs_Lock();
-	h = yaffsfs_GetHandlePointer(fd);
-	obj = yaffsfs_GetHandleObject(fd);
+	fd = yaffsfs_HandleToFileDes(handle);
+	obj = yaffsfs_HandleToObject(handle);
 
-	if(!h || !obj){
+	if(!fd || !obj){
 		/* bad handle */
 		yaffsfs_SetError(-EBADF);
 		totalRead = -1;
-	} else if( h && obj){
+	} else if(!fd->reading){
+		/* Not a reading handle */
+		yaffsfs_SetError(-EINVAL);
+		totalRead = -1;
+	} else if(nbyte > YAFFS_MAX_FILE_SIZE){
+		yaffsfs_SetError(-EINVAL);
+		totalRead = -1;
+	} else {
 		if(isPread)
 			startPos = offset;
 		else
-			startPos = h->position;
+			startPos = fd->position;
 
 		pos = startPos;
-					
-		if(yaffs_GetObjectFileLength(obj) > pos)
-			maxRead = yaffs_GetObjectFileLength(obj) - pos;
+
+		if(yaffs_get_obj_length(obj) > pos)
+			maxRead = yaffs_get_obj_length(obj) - pos;
 		else
 			maxRead = 0;
 
@@ -848,13 +1112,31 @@ int yaffsfs_do_read(int fd, void *vbuf, unsigned int nbyte, int isPread, int off
 			nbyte = maxRead;
 
 
-		yaffsfs_GetHandle(fd);
+		yaffsfs_GetHandle(handle);
+
+		endPos = pos + nbyte;
+
+		if(pos < 0 || pos > YAFFS_MAX_FILE_SIZE ||
+			nbyte > YAFFS_MAX_FILE_SIZE ||
+			endPos < 0 || endPos > YAFFS_MAX_FILE_SIZE){
+			totalRead = -1;
+			nbyte = 0;
+		}
 
 		while(nbyte > 0) {
 			nToRead = YAFFSFS_RW_SIZE - (pos & (YAFFSFS_RW_SIZE -1));
 			if(nToRead > nbyte)
 				nToRead = nbyte;
-			nRead = yaffs_ReadDataFromFile(obj,buf,pos,nToRead);
+
+			/* Tricky bit...
+			 * Need to reverify object in case the device was
+			 * unmounted in another thread.
+			 */
+			obj = yaffsfs_HandleToObject(handle);
+			if(!obj)
+				nRead = 0;
+			else
+				nRead = yaffs_file_rd(obj,buf,pos,nToRead);
 
 			if(nRead > 0){
 				totalRead += nRead;
@@ -866,8 +1148,8 @@ int yaffsfs_do_read(int fd, void *vbuf, unsigned int nbyte, int isPread, int off
 				nbyte-=nRead;
 			else
 				nbyte = 0; /* no more to read */
-					
-					
+
+
 			if(nbyte > 0){
 				yaffsfs_Unlock();
 				yaffsfs_Lock();
@@ -875,14 +1157,13 @@ int yaffsfs_do_read(int fd, void *vbuf, unsigned int nbyte, int isPread, int off
 
 		}
 
-		yaffsfs_PutHandle(fd);
+		yaffsfs_PutHandle(handle);
 
 		if(!isPread) {
 			if(totalRead >= 0)
-				h->position = startPos + totalRead;
-			else {
-					/* todo error */
-			}
+				fd->position = startPos + totalRead;
+			else
+				yaffsfs_SetError(-EINVAL);
 		}
 
 	}
@@ -893,55 +1174,83 @@ int yaffsfs_do_read(int fd, void *vbuf, unsigned int nbyte, int isPread, int off
 
 }
 
-int yaffs_read(int fd, void *buf, unsigned int nbyte)
+int yaffs_read(int handle, void *buf, unsigned int nbyte)
 {
-	return yaffsfs_do_read(fd, buf, nbyte, 0, 0);
+	return yaffsfs_do_read(handle, buf, nbyte, 0, 0);
 }
 
-int yaffs_pread(int fd, void *buf, unsigned int nbyte, unsigned int offset)
+int yaffs_pread(int handle, void *buf, unsigned int nbyte, loff_t offset)
 {
-	return yaffsfs_do_read(fd, buf, nbyte, 1, offset);
+	return yaffsfs_do_read(handle, buf, nbyte, 1, offset);
 }
 
-int yaffsfs_do_write(int fd, const void *vbuf, unsigned int nbyte, int isPwrite, int offset)
+int yaffsfs_do_write(int handle, const void *vbuf, unsigned int nbyte, int isPwrite, loff_t offset)
 {
-	yaffsfs_Handle *h = NULL;
-	yaffs_Object *obj = NULL;
-	int pos = 0;
-	int startPos = 0;
+	yaffsfs_FileDes *fd = NULL;
+	struct yaffs_obj *obj = NULL;
+	loff_t pos = 0;
+	loff_t startPos = 0;
+	loff_t endPos;
 	int nWritten = 0;
 	int totalWritten = 0;
-	int writeThrough = 0;
+	int write_trhrough = 0;
 	int nToWrite = 0;
-	const __u8 *buf = (const __u8 *)vbuf;
+	const u8 *buf = (const u8 *)vbuf;
+
+	if(!vbuf){
+		yaffsfs_SetError(-EFAULT);
+		return -1;
+	}
 
 	yaffsfs_Lock();
-	h = yaffsfs_GetHandlePointer(fd);
-	obj = yaffsfs_GetHandleObject(fd);
+	fd = yaffsfs_HandleToFileDes(handle);
+	obj = yaffsfs_HandleToObject(handle);
 
-	if(!h || !obj){
+	if(!fd || !obj){
 		/* bad handle */
 		yaffsfs_SetError(-EBADF);
 		totalWritten = -1;
-	} else if( h && obj && (!h->writing || obj->myDev->readOnly)){
+	} else if(!fd->writing){
 		yaffsfs_SetError(-EINVAL);
 		totalWritten=-1;
-	} else if( h && obj){
-		if(h->append)
-			startPos = yaffs_GetObjectFileLength(obj);
+	} else if(obj->my_dev->read_only){
+		yaffsfs_SetError(-EROFS);
+		totalWritten=-1;
+	} else {
+		if(fd->append)
+			startPos = yaffs_get_obj_length(obj);
 		else if(isPwrite)
 			startPos = offset;
 		else
-			startPos = h->position;
+			startPos = fd->position;
 
-		yaffsfs_GetHandle(fd);
+		yaffsfs_GetHandle(handle);
 		pos = startPos;
+		endPos = pos + nbyte;
+
+		if(pos < 0 || pos > YAFFS_MAX_FILE_SIZE ||
+			nbyte > YAFFS_MAX_FILE_SIZE ||
+			endPos < 0 || endPos > YAFFS_MAX_FILE_SIZE){
+			totalWritten = -1;
+			nbyte = 0;
+		}
+
 		while(nbyte > 0) {
+
 			nToWrite = YAFFSFS_RW_SIZE - (pos & (YAFFSFS_RW_SIZE -1));
 			if(nToWrite > nbyte)
 				nToWrite = nbyte;
 
-			nWritten = yaffs_WriteDataToFile(obj,buf,pos,nToWrite,writeThrough);
+			/* Tricky bit...
+			 * Need to reverify object in case the device was
+			 * remounted or unmounted in another thread.
+			 */
+			obj = yaffsfs_HandleToObject(handle);
+			if(!obj || obj->my_dev->read_only)
+				nWritten = 0;
+			else
+				nWritten = yaffs_wr_file(obj,buf,pos,nToWrite,
+							write_trhrough);
 			if(nWritten > 0){
 				totalWritten += nWritten;
 				pos += nWritten;
@@ -964,14 +1273,13 @@ int yaffsfs_do_write(int fd, const void *vbuf, unsigned int nbyte, int isPwrite,
 			}
 		}
 
-		yaffsfs_PutHandle(fd);
+		yaffsfs_PutHandle(handle);
 
 		if(!isPwrite){
 			if(totalWritten > 0)
-				h->position = startPos + totalWritten;
-			else {
-				/* todo error */
-			}
+				fd->position = startPos + totalWritten;
+			else
+				yaffsfs_SetError(-EINVAL);
 		}
 	}
 
@@ -985,95 +1293,120 @@ int yaffs_write(int fd, const void *buf, unsigned int nbyte)
 	return yaffsfs_do_write(fd, buf, nbyte, 0, 0);
 }
 
-int yaffs_pwrite(int fd, const void *buf, unsigned int nbyte, unsigned int offset)
+int yaffs_pwrite(int fd, const void *buf, unsigned int nbyte, loff_t offset)
 {
 	return yaffsfs_do_write(fd, buf, nbyte, 1, offset);
 }
 
 
-int yaffs_truncate(const YCHAR *path,off_t newSize)
+int yaffs_truncate(const YCHAR *path,loff_t new_size)
 {
-	yaffs_Object *obj = NULL;
+	struct yaffs_obj *obj = NULL;
+	struct yaffs_obj *dir = NULL;
 	int result = YAFFS_FAIL;
+	int notDir = 0;
+	int loop = 0;
+
+	if(!path){
+		yaffsfs_SetError(-EFAULT);
+		return -1;
+	}
+
+	if(yaffsfs_CheckPath(path) < 0){
+		yaffsfs_SetError(-ENAMETOOLONG);
+		return -1;
+	}
 
 	yaffsfs_Lock();
 
-	obj = yaffsfs_FindObject(NULL,path,0,1);
+	obj = yaffsfs_FindObject(NULL,path,0,1,&dir,&notDir,&loop);
+	obj = yaffsfs_FollowLink(obj,0,&loop);
 
-	if(!obj)
+	if(!dir && notDir)
+		yaffsfs_SetError(-ENOTDIR);
+	else if(loop)
+		yaffsfs_SetError(-ELOOP);
+	else if(!dir || !obj)
 		yaffsfs_SetError(-ENOENT);
-	else if(obj->variantType != YAFFS_OBJECT_TYPE_FILE)
+	else if(obj->my_dev->read_only)
+		yaffsfs_SetError(-EROFS);
+	else if(obj->variant_type != YAFFS_OBJECT_TYPE_FILE)
 		yaffsfs_SetError(-EISDIR);
-	else if(obj->myDev->readOnly)
+	else if(obj->my_dev->read_only)
+		yaffsfs_SetError(-EROFS);
+	else if(new_size < 0 || new_size > YAFFS_MAX_FILE_SIZE)
 		yaffsfs_SetError(-EINVAL);
 	else
-		result = yaffs_ResizeFile(obj,newSize);
+		result = yaffs_resize_file(obj, new_size);
 
 	yaffsfs_Unlock();
 
-
 	return (result) ? 0 : -1;
 }
 
-int yaffs_ftruncate(int fd, off_t newSize)
+int yaffs_ftruncate(int handle, loff_t new_size)
 {
-	yaffsfs_Handle *h = NULL;
-	yaffs_Object *obj = NULL;
+	yaffsfs_FileDes *fd = NULL;
+	struct yaffs_obj *obj = NULL;
 	int result = 0;
 
 	yaffsfs_Lock();
-	h = yaffsfs_GetHandlePointer(fd);
-	obj = yaffsfs_GetHandleObject(fd);
+	fd = yaffsfs_HandleToFileDes(handle);
+	obj = yaffsfs_HandleToObject(handle);
 
-	if(!h || !obj)
+	if(!fd || !obj)
 		/* bad handle */
 		yaffsfs_SetError(-EBADF);
-	else if(obj->myDev->readOnly)
+	else if(!fd->writing)
+		yaffsfs_SetError(-EINVAL);
+	else if(obj->my_dev->read_only)
+		yaffsfs_SetError(-EROFS);
+	else if( new_size < 0 || new_size > YAFFS_MAX_FILE_SIZE)
 		yaffsfs_SetError(-EINVAL);
 	else
 		/* resize the file */
-		result = yaffs_ResizeFile(obj,newSize);
+		result = yaffs_resize_file(obj, new_size);
 	yaffsfs_Unlock();
 
-
 	return (result) ? 0 : -1;
 
 }
 
-off_t yaffs_lseek(int fd, off_t offset, int whence)
+loff_t yaffs_lseek(int handle, loff_t offset, int whence)
 {
-	yaffsfs_Handle *h = NULL;
-	yaffs_Object *obj = NULL;
-	int pos = -1;
-	int fSize = -1;
+	yaffsfs_FileDes *fd = NULL;
+	struct yaffs_obj *obj = NULL;
+	loff_t pos = -1;
+	loff_t fSize = -1;
 
 	yaffsfs_Lock();
-	h = yaffsfs_GetHandlePointer(fd);
-	obj = yaffsfs_GetHandleObject(fd);
+	fd = yaffsfs_HandleToFileDes(handle);
+	obj = yaffsfs_HandleToObject(handle);
 
-	if(!h || !obj)
-		/* bad handle */
+	if(!fd || !obj)
 		yaffsfs_SetError(-EBADF);
-	else if(whence == SEEK_SET){
-		if(offset >= 0)
-			pos = offset;
-	}
-	else if(whence == SEEK_CUR) {
-		if( (h->position + offset) >= 0)
-			pos = (h->position + offset);
-	}
-	else if(whence == SEEK_END) {
-		fSize = yaffs_GetObjectFileLength(obj);
-		if(fSize >= 0 && (fSize + offset) >= 0)
-			pos = fSize + offset;
-	}
-
-	if(pos >= 0)
-		h->position = pos;
+	else if(offset > YAFFS_MAX_FILE_SIZE)
+		yaffsfs_SetError(-EINVAL);
 	else {
-		/* todo error */
-	}
+		if(whence == SEEK_SET){
+			if(offset >= 0)
+				pos = offset;
+		} else if(whence == SEEK_CUR) {
+			if( (fd->position + offset) >= 0)
+				pos = (fd->position + offset);
+		} else if(whence == SEEK_END) {
+			fSize = yaffs_get_obj_length(obj);
+			if(fSize >= 0 && (fSize + offset) >= 0)
+				pos = fSize + offset;
+		}
 
+		if(pos >= 0 && pos <= YAFFS_MAX_FILE_SIZE)
+			fd->position = pos;
+		else{
+			yaffsfs_SetError(-EINVAL);
+			pos = -1;
+		}
+	}
 
 	yaffsfs_Unlock();
 
@@ -1083,27 +1416,48 @@ off_t yaffs_lseek(int fd, off_t offset, int whence)
 
 int yaffsfs_DoUnlink(const YCHAR *path,int isDirectory)
 {
-	yaffs_Object *dir = NULL;
-	yaffs_Object *obj = NULL;
+	struct yaffs_obj *dir = NULL;
+	struct yaffs_obj *obj = NULL;
 	YCHAR *name;
 	int result = YAFFS_FAIL;
+	int notDir = 0;
+	int loop = 0;
+
+	if(!path){
+		yaffsfs_SetError(-EFAULT);
+		return -1;
+	}
+
+	if(yaffsfs_CheckPath(path) < 0){
+		yaffsfs_SetError(-ENAMETOOLONG);
+		return -1;
+	}
 
 	yaffsfs_Lock();
 
-	obj = yaffsfs_FindObject(NULL,path,0,0);
-	dir = yaffsfs_FindDirectory(NULL,path,&name,0);
-	if(!dir)
+	obj = yaffsfs_FindObject(NULL,path,0,0,NULL,NULL,NULL);
+	dir = yaffsfs_FindDirectory(NULL,path,&name,0,&notDir,&loop);
+
+	if(!dir && notDir)
 		yaffsfs_SetError(-ENOTDIR);
-	else if(!obj)
+	else if(loop)
+		yaffsfs_SetError(-ELOOP);
+	else if(!dir)
 		yaffsfs_SetError(-ENOENT);
-	else if(obj->myDev->readOnly)
+	else if(yaffs_strncmp(name,_Y("."),2) == 0)
 		yaffsfs_SetError(-EINVAL);
-	else if(!isDirectory && obj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY)
+	else if(!obj)
+		yaffsfs_SetError(-ENOENT);
+	else if(obj->my_dev->read_only)
+		yaffsfs_SetError(-EROFS);
+	else if(!isDirectory && obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY)
 		yaffsfs_SetError(-EISDIR);
-	else if(isDirectory && obj->variantType != YAFFS_OBJECT_TYPE_DIRECTORY)
+	else if(isDirectory && obj->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY)
 		yaffsfs_SetError(-ENOTDIR);
+	else if(isDirectory && obj == obj->my_dev->root_dir)
+		yaffsfs_SetError(-EBUSY); /* Can't rmdir a root */
 	else {
-		result = yaffs_Unlink(dir,name);
+		result = yaffs_unlinker(dir,name);
 
 		if(result == YAFFS_FAIL && isDirectory)
 			yaffsfs_SetError(-ENOTEMPTY);
@@ -1111,17 +1465,10 @@ int yaffsfs_DoUnlink(const YCHAR *path,int isDirectory)
 
 	yaffsfs_Unlock();
 
-	/* todo error */
-
 	return (result == YAFFS_FAIL) ? -1 : 0;
 }
 
 
-int yaffs_rmdir(const YCHAR *path)
-{
-	return yaffsfs_DoUnlink(path,1);
-}
-
 int yaffs_unlink(const YCHAR *path)
 {
 	return yaffsfs_DoUnlink(path,0);
@@ -1129,83 +1476,133 @@ int yaffs_unlink(const YCHAR *path)
 
 int yaffs_rename(const YCHAR *oldPath, const YCHAR *newPath)
 {
-	yaffs_Object *olddir = NULL;
-	yaffs_Object *newdir = NULL;
-	yaffs_Object *obj = NULL;
+	struct yaffs_obj *olddir = NULL;
+	struct yaffs_obj *newdir = NULL;
+	struct yaffs_obj *obj = NULL;
+	struct yaffs_obj *newobj = NULL;
 	YCHAR *oldname;
 	YCHAR *newname;
 	int result= YAFFS_FAIL;
-	int renameAllowed = 1;
+	int rename_allowed = 1;
+	int notOldDir = 0;
+	int notNewDir = 0;
+	int oldLoop = 0;
+	int newLoop = 0;
+
+	YCHAR *alt_newpath=NULL;
+
+	if(!oldPath || !newPath){
+		yaffsfs_SetError(-EFAULT);
+		return -1;
+	}
+
+	if(yaffsfs_CheckPath(oldPath) < 0 ||
+		yaffsfs_CheckPath(newPath) < 0){
+		yaffsfs_SetError(-ENAMETOOLONG);
+		return -1;
+	}
+
+	if(yaffsfs_alt_dir_path(newPath, &alt_newpath) < 0){
+		yaffsfs_SetError(-ENOMEM);
+		return -1;
+	}
+	if(alt_newpath)
+		newPath = alt_newpath;
 
 	yaffsfs_Lock();
 
-	olddir = yaffsfs_FindDirectory(NULL,oldPath,&oldname,0);
-	newdir = yaffsfs_FindDirectory(NULL,newPath,&newname,0);
-	obj = yaffsfs_FindObject(NULL,oldPath,0,0);
 
-	if(!olddir || !newdir || !obj) {
-		/* bad file */
-		yaffsfs_SetError(-EBADF);
-		renameAllowed = 0;
-	} else if(obj->myDev->readOnly){
+	olddir = yaffsfs_FindDirectory(NULL,oldPath,&oldname,0,&notOldDir,&oldLoop);
+	newdir = yaffsfs_FindDirectory(NULL,newPath,&newname,0,&notNewDir,&newLoop);
+	obj = yaffsfs_FindObject(NULL,oldPath,0,0,NULL,NULL,NULL);
+	newobj = yaffsfs_FindObject(NULL,newPath,0,0,NULL,NULL,NULL);
+
+	/* If the object being renamed is a directory and the
+	 * path ended with a "/" then the olddir == obj.
+	 * We pass through NULL for the old name to tell the lower layers
+	 * to use olddir as the object.
+	 */
+
+	if(olddir == obj)
+		oldname = NULL;
+
+	if((!olddir && notOldDir) || (!newdir && notNewDir)) {
+		yaffsfs_SetError(-ENOTDIR);
+		rename_allowed = 0;
+	} else if(oldLoop || newLoop) {
+		yaffsfs_SetError(-ELOOP);
+		rename_allowed = 0;
+	} else if (olddir && oldname && yaffs_strncmp(oldname, _Y("."),2) == 0){
 		yaffsfs_SetError(-EINVAL);
-		renameAllowed = 0;
-	} else if(olddir->myDev != newdir->myDev) {
-		/* oops must be on same device */
-		/* todo error */
+		rename_allowed = 0;
+	}else if(!olddir || !newdir || !obj) {
+		yaffsfs_SetError(-ENOENT);
+		rename_allowed = 0;
+	} else if(obj->my_dev->read_only){
+		yaffsfs_SetError(-EROFS);
+		rename_allowed = 0;
+	} else if(yaffs_is_non_empty_dir(newobj)){
+		yaffsfs_SetError(-ENOTEMPTY);
+		rename_allowed = 0;
+	} else if(olddir->my_dev != newdir->my_dev) {
+		/* Rename must be on same device */
 		yaffsfs_SetError(-EXDEV);
-		renameAllowed = 0;
-	} else if(obj && obj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY) {
+		rename_allowed = 0;
+	} else if(obj && obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) {
 		/*
 		 * It is a directory, check that it is not being renamed to
 		 * being its own decendent.
-		 * Do this by tracing from the new directory back to the root, checking for obj
+		 * Do this by tracing from the new directory back to the root,
+		 * checking for obj
 		 */
 
-		yaffs_Object *xx = newdir;
+		struct yaffs_obj *xx = newdir;
 
-		while( renameAllowed && xx){
+		while( rename_allowed && xx){
 			if(xx == obj)
-				renameAllowed = 0;
+				rename_allowed = 0;
 			xx = xx->parent;
 		}
-		if(!renameAllowed)
-			yaffsfs_SetError(-EACCES);
+		if(!rename_allowed)
+			yaffsfs_SetError(-EINVAL);
 	}
 
-	if(renameAllowed)
-		result = yaffs_RenameObject(olddir,oldname,newdir,newname);
+	if(rename_allowed)
+		result = yaffs_rename_obj(olddir,oldname,newdir,newname);
 
 	yaffsfs_Unlock();
 
+	if(alt_newpath)
+		kfree(alt_newpath);
+
 	return (result == YAFFS_FAIL) ? -1 : 0;
 }
 
 
-static int yaffsfs_DoStat(yaffs_Object *obj,struct yaffs_stat *buf)
+static int yaffsfs_DoStat(struct yaffs_obj *obj,struct yaffs_stat *buf)
 {
 	int retVal = -1;
 
-	obj = yaffs_GetEquivalentObject(obj);
+	obj = yaffs_get_equivalent_obj(obj);
 
 	if(obj && buf){
-	    	buf->st_dev = (int)obj->myDev->osContext;
-	    	buf->st_ino = obj->objectId;
+	    	buf->st_dev = (int)obj->my_dev->os_context;
+	    	buf->st_ino = obj->obj_id;
 	    	buf->st_mode = obj->yst_mode & ~S_IFMT; /* clear out file type bits */
 
-	    	if(obj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY)
+	    	if(obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY)
 			buf->st_mode |= S_IFDIR;
-		else if(obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK)
+		else if(obj->variant_type == YAFFS_OBJECT_TYPE_SYMLINK)
 			buf->st_mode |= S_IFLNK;
-		else if(obj->variantType == YAFFS_OBJECT_TYPE_FILE)
+		else if(obj->variant_type == YAFFS_OBJECT_TYPE_FILE)
 			buf->st_mode |= S_IFREG;
 
-	    	buf->st_nlink = yaffs_GetObjectLinkCount(obj);
+	    	buf->st_nlink = yaffs_get_obj_link_count(obj);
 	    	buf->st_uid = 0;
 	    	buf->st_gid = 0;;
 	    	buf->st_rdev = obj->yst_rdev;
-	    	buf->st_size = yaffs_GetObjectFileLength(obj);
-	    	buf->st_blksize = obj->myDev->nDataBytesPerChunk;
+	    	buf->st_size = yaffs_get_obj_length(obj);
+	    	buf->st_blksize = obj->my_dev->data_bytes_per_chunk;
 	    	buf->st_blocks = (buf->st_size + buf->st_blksize -1)/buf->st_blksize;
 #if CONFIG_YAFFS_WINCE
 		buf->yst_wince_atime[0] = obj->win_atime[0];
@@ -1226,22 +1623,37 @@ static int yaffsfs_DoStat(yaffs_Object *obj,struct yaffs_stat *buf)
 
 static int yaffsfs_DoStatOrLStat(const YCHAR *path, struct yaffs_stat *buf,int doLStat)
 {
-	yaffs_Object *obj;
-
+	struct yaffs_obj *obj=NULL;
+	struct yaffs_obj *dir=NULL;
 	int retVal = -1;
+	int notDir = 0;
+	int loop = 0;
+
+	if(!path || !buf){
+		yaffsfs_SetError(-EFAULT);
+		return -1;
+	}
+
+	if(yaffsfs_CheckPath(path) < 0){
+		yaffsfs_SetError(-ENAMETOOLONG);
+		return -1;
+	}
 
 	yaffsfs_Lock();
 
-	obj = yaffsfs_FindObject(NULL,path,0,1);
+	obj = yaffsfs_FindObject(NULL,path,0,1,&dir,&notDir,&loop);
 
 	if(!doLStat && obj)
-		obj = yaffsfs_FollowLink(obj,0);
+		obj = yaffsfs_FollowLink(obj,0,&loop);
 
-	if(obj)
-		retVal = yaffsfs_DoStat(obj,buf);
-	else
-		/* todo error not found */
+	if(!dir && notDir)
+		yaffsfs_SetError(-ENOTDIR);
+	else if(loop)
+		yaffsfs_SetError(-ELOOP);
+	else if(!dir || !obj)
 		yaffsfs_SetError(-ENOENT);
+	else
+		retVal = yaffsfs_DoStat(obj,buf);
 
 	yaffsfs_Unlock();
 
@@ -1261,12 +1673,17 @@ int yaffs_lstat(const YCHAR *path, struct yaffs_stat *buf)
 
 int yaffs_fstat(int fd, struct yaffs_stat *buf)
 {
-	yaffs_Object *obj;
+	struct yaffs_obj *obj;
 
 	int retVal = -1;
 
+	if(!buf){
+		yaffsfs_SetError(-EFAULT);
+		return -1;
+	}
+
 	yaffsfs_Lock();
-	obj = yaffsfs_GetHandleObject(fd);
+	obj = yaffsfs_HandleToObject(fd);
 
 	if(obj)
 		retVal = yaffsfs_DoStat(obj,buf);
@@ -1279,32 +1696,139 @@ int yaffs_fstat(int fd, struct yaffs_stat *buf)
 	return retVal;
 }
 
+static int yaffsfs_DoUtime(struct yaffs_obj *obj,const struct yaffs_utimbuf *buf)
+{
+	int retVal = -1;
+	int result;
+
+	struct yaffs_utimbuf local;
+
+	obj = yaffs_get_equivalent_obj(obj);
+
+	if(obj && obj->my_dev->read_only) {
+		yaffsfs_SetError(-EROFS);
+		return -1;
+	}
+
+
+	if(!buf){
+		local.actime = Y_CURRENT_TIME;
+		local.modtime = local.actime;
+		buf = &local;
+	}
+
+	if(obj){
+		obj->yst_atime = buf->actime;
+		obj->yst_mtime = buf->modtime;
+		obj->dirty = 1;
+		result = yaffs_flush_file(obj,0,0);
+		retVal = result == YAFFS_OK ? 0 : -1;
+	}
+
+	return retVal;
+}
+
+int yaffs_utime(const YCHAR *path, const struct yaffs_utimbuf *buf)
+{
+	struct yaffs_obj *obj=NULL;
+	struct yaffs_obj *dir=NULL;
+	int retVal = -1;
+	int notDir = 0;
+	int loop = 0;
+
+	if(!path){
+		yaffsfs_SetError(-EFAULT);
+		return -1;
+	}
+
+	if(yaffsfs_CheckPath(path) < 0){
+		yaffsfs_SetError(-ENAMETOOLONG);
+		return -1;
+	}
+
+	yaffsfs_Lock();
+
+	obj = yaffsfs_FindObject(NULL,path,0,1,&dir,&notDir,&loop);
+
+	if(!dir && notDir)
+		yaffsfs_SetError(-ENOTDIR);
+	else if(loop)
+		yaffsfs_SetError(-ELOOP);
+	else if(!dir || !obj)
+		yaffsfs_SetError(-ENOENT);
+	else
+		retVal = yaffsfs_DoUtime(obj,buf);
+
+	yaffsfs_Unlock();
+
+	return retVal;
+
+}
+int yaffs_futime(int fd, const struct yaffs_utimbuf *buf)
+{
+	struct yaffs_obj *obj;
+
+	int retVal = -1;
+
+	yaffsfs_Lock();
+	obj = yaffsfs_HandleToObject(fd);
+
+	if(obj)
+		retVal = yaffsfs_DoUtime(obj,buf);
+	else
+		/* bad handle */
+		yaffsfs_SetError(-EBADF);
+
+	yaffsfs_Unlock();
+
+	return retVal;
+}
+
+
 #ifndef CONFIG_YAFFS_WINCE
 /* xattrib functions */
 
 
-static int yaffs_do_setxattr(const YCHAR *path, const char *name, const void *data, int size, int flags, int follow)
+static int yaffs_do_setxattr(const YCHAR *path, const char *name,
+			const void *data, int size, int flags, int follow)
 {
-	yaffs_Object *obj;
+	struct yaffs_obj *obj;
+	struct yaffs_obj *dir;
+	int notDir = 0;
+	int loop = 0;
 
 	int retVal = -1;
 
+	if(!path || !name || !data){
+		yaffsfs_SetError(-EFAULT);
+		return -1;
+	}
+
+	if(yaffsfs_CheckPath(path) < 0){
+		yaffsfs_SetError(-ENAMETOOLONG);
+		return -1;
+	}
+
 	yaffsfs_Lock();
 
-	obj = yaffsfs_FindObject(NULL,path,0,1);
+	obj = yaffsfs_FindObject(NULL,path,0,1,&dir,&notDir,&loop);
 
 	if(follow)
-		obj = yaffsfs_FollowLink(obj,0);
+		obj = yaffsfs_FollowLink(obj,0,&loop);
 
-	if(obj) {
-		retVal = yaffs_SetXAttribute(obj,name,data,size,flags);
+	if(!dir && notDir)
+		yaffsfs_SetError(-ENOTDIR);
+	else if(loop)
+		yaffsfs_SetError(-ELOOP);
+	else if(!dir || !obj)
+		yaffsfs_SetError(-ENOENT);
+	else {
+		retVal = yaffs_set_xattrib(obj,name,data,size,flags);
 		if(retVal< 0){
 			yaffsfs_SetError(retVal);
 			retVal = -1;
 		}
-	} else
-		/* todo error not found */
-		yaffsfs_SetError(-ENOENT);
+	}
 
 	yaffsfs_Unlock();
 
@@ -1326,22 +1850,27 @@ int yaffs_lsetxattr(const YCHAR *path, const char *name, const void *data, int s
 
 int yaffs_fsetxattr(int fd, const char *name, const void *data, int size, int flags)
 {
-	yaffs_Object *obj;
+	struct yaffs_obj *obj;
 
 	int retVal = -1;
 
+	if(!name || !data){
+		yaffsfs_SetError(-EFAULT);
+		return -1;
+	}
+
 	yaffsfs_Lock();
-	obj = yaffsfs_GetHandleObject(fd);
+	obj = yaffsfs_HandleToObject(fd);
 
-	if(obj) {
-		retVal = yaffs_SetXAttribute(obj,name,data,size,flags);
+	if(!obj)
+		yaffsfs_SetError(-EBADF);
+	else {
+		retVal = yaffs_set_xattrib(obj,name,data,size,flags);
 		if(retVal< 0){
 			yaffsfs_SetError(retVal);
 			retVal = -1;
 		}
-	} else
-		/* bad handle */
-		yaffsfs_SetError(-EBADF);
+	}
 
 	yaffsfs_Unlock();
 
@@ -1350,27 +1879,42 @@ int yaffs_fsetxattr(int fd, const char *name, const void *data, int size, int fl
 
 static int yaffs_do_getxattr(const YCHAR *path, const char *name, void *data, int size, int follow)
 {
-	yaffs_Object *obj;
-
+	struct yaffs_obj *obj;
+	struct yaffs_obj *dir;
 	int retVal = -1;
+	int notDir = 0;
+	int loop = 0;
+
+	if(!path || !name || !data ){
+		yaffsfs_SetError(-EFAULT);
+		return -1;
+	}
+
+	if(yaffsfs_CheckPath(path) < 0){
+		yaffsfs_SetError(-ENAMETOOLONG);
+		return -1;
+	}
 
 	yaffsfs_Lock();
 
-	obj = yaffsfs_FindObject(NULL,path,0,1);
+	obj = yaffsfs_FindObject(NULL,path,0,1,&dir,&notDir,&loop);
 
 	if(follow)
-		obj = yaffsfs_FollowLink(obj,0);
+		obj = yaffsfs_FollowLink(obj,0,&loop);
 
-	if(obj) {
-		retVal = yaffs_GetXAttribute(obj,name,data,size);
+	if(!dir && notDir)
+		yaffsfs_SetError(-ENOTDIR);
+	else if(loop)
+		yaffsfs_SetError(-ELOOP);
+	else if(!dir || !obj)
+		yaffsfs_SetError(-ENOENT);
+	else {
+		retVal = yaffs_get_xattrib(obj,name,data,size);
 		if(retVal< 0){
 			yaffsfs_SetError(retVal);
 			retVal = -1;
 		}
-	} else
-		/* todo error not found */
-		yaffsfs_SetError(-ENOENT);
-
+	}
 	yaffsfs_Unlock();
 
 	return retVal;
@@ -1390,15 +1934,20 @@ int yaffs_lgetxattr(const YCHAR *path, const char *name, void *data, int size)
 
 int yaffs_fgetxattr(int fd, const char *name, void *data, int size)
 {
-	yaffs_Object *obj;
+	struct yaffs_obj *obj;
 
 	int retVal = -1;
 
+	if(!name || !data ){
+		yaffsfs_SetError(-EFAULT);
+		return -1;
+	}
+
 	yaffsfs_Lock();
-	obj = yaffsfs_GetHandleObject(fd);
+	obj = yaffsfs_HandleToObject(fd);
 
 	if(obj) {
-		retVal = yaffs_GetXAttribute(obj,name,data,size);
+		retVal = yaffs_get_xattrib(obj,name,data,size);
 		if(retVal< 0){
 			yaffsfs_SetError(retVal);
 			retVal = -1;
@@ -1414,26 +1963,42 @@ int yaffs_fgetxattr(int fd, const char *name, void *data, int size)
 
 static int yaffs_do_listxattr(const YCHAR *path, char *data, int size, int follow)
 {
-	yaffs_Object *obj;
-
+	struct yaffs_obj *obj=NULL;
+	struct yaffs_obj *dir=NULL;
 	int retVal = -1;
+	int notDir = 0;
+	int loop = 0;
+
+	if(!path || !data ){
+		yaffsfs_SetError(-EFAULT);
+		return -1;
+	}
+
+	if(yaffsfs_CheckPath(path) < 0){
+		yaffsfs_SetError(-ENAMETOOLONG);
+		return -1;
+	}
 
 	yaffsfs_Lock();
 
-	obj = yaffsfs_FindObject(NULL,path,0,1);
+	obj = yaffsfs_FindObject(NULL,path,0,1,&dir,&notDir,&loop);
 
 	if(follow)
-		obj = yaffsfs_FollowLink(obj,0);
+		obj = yaffsfs_FollowLink(obj,0,&loop);
 
-	if(obj) {
-		retVal = yaffs_ListXAttributes(obj, data,size);
+	if(!dir && notDir)
+		yaffsfs_SetError(-ENOTDIR);
+	else if(loop)
+		yaffsfs_SetError(-ELOOP);
+	else if(!dir || !obj)
+		yaffsfs_SetError(-ENOENT);
+	else {
+		retVal = yaffs_list_xattrib(obj, data,size);
 		if(retVal< 0){
 			yaffsfs_SetError(retVal);
 			retVal = -1;
 		}
-	} else
-		/* todo error not found */
-		yaffsfs_SetError(-ENOENT);
+	}
 
 	yaffsfs_Unlock();
 
@@ -1453,15 +2018,20 @@ int yaffs_llistxattr(const YCHAR *path, char *data, int size)
 
 int yaffs_flistxattr(int fd, char *data, int size)
 {
-	yaffs_Object *obj;
+	struct yaffs_obj *obj;
 
 	int retVal = -1;
 
+	if(!data ){
+		yaffsfs_SetError(-EFAULT);
+		return -1;
+	}
+
 	yaffsfs_Lock();
-	obj = yaffsfs_GetHandleObject(fd);
+	obj = yaffsfs_HandleToObject(fd);
 
 	if(obj) {
-		retVal = yaffs_ListXAttributes(obj,data,size);
+		retVal = yaffs_list_xattrib(obj,data,size);
 		if(retVal< 0){
 			yaffsfs_SetError(retVal);
 			retVal = -1;
@@ -1477,26 +2047,42 @@ int yaffs_flistxattr(int fd, char *data, int size)
 
 static int yaffs_do_removexattr(const YCHAR *path, const char *name, int follow)
 {
-	yaffs_Object *obj;
-
+	struct yaffs_obj *obj=NULL;
+	struct yaffs_obj *dir=NULL;
+	int notDir = 0;
+	int loop = 0;
 	int retVal = -1;
 
+	if(!path || !name){
+		yaffsfs_SetError(-EFAULT);
+		return -1;
+	}
+
+	if(yaffsfs_CheckPath(path) < 0){
+		yaffsfs_SetError(-ENAMETOOLONG);
+		return -1;
+	}
+
 	yaffsfs_Lock();
 
-	obj = yaffsfs_FindObject(NULL,path,0,1);
+	obj = yaffsfs_FindObject(NULL,path,0,1, &dir,&notDir,&loop);
 
 	if(follow)
-		obj = yaffsfs_FollowLink(obj,0);
+		obj = yaffsfs_FollowLink(obj,0,&loop);
 
-	if(obj) {
-		retVal = yaffs_RemoveXAttribute(obj,name);
+	if(!dir && notDir)
+		yaffsfs_SetError(-ENOTDIR);
+	else if(loop)
+		yaffsfs_SetError(-ELOOP);
+	else if(!dir || !obj)
+		yaffsfs_SetError(-ENOENT);
+	else {
+		retVal = yaffs_remove_xattrib(obj,name);
 		if(retVal< 0){
 			yaffsfs_SetError(retVal);
 			retVal = -1;
 		}
-	} else
-		/* todo error not found */
-		yaffsfs_SetError(-ENOENT);
+	}
 
 	yaffsfs_Unlock();
 
@@ -1516,15 +2102,20 @@ int yaffs_lremovexattr(const YCHAR *path, const char *name)
 
 int yaffs_fremovexattr(int fd, const char *name)
 {
-	yaffs_Object *obj;
+	struct yaffs_obj *obj;
 
 	int retVal = -1;
 
+	if(!name){
+		yaffsfs_SetError(-EFAULT);
+		return -1;
+	}
+
 	yaffsfs_Lock();
-	obj = yaffsfs_GetHandleObject(fd);
+	obj = yaffsfs_HandleToObject(fd);
 
 	if(obj){
-		retVal = yaffs_RemoveXAttribute(obj,name);
+		retVal = yaffs_remove_xattrib(obj,name);
 		if(retVal< 0){
 			yaffsfs_SetError(retVal);
 			retVal = -1;
@@ -1542,12 +2133,12 @@ int yaffs_fremovexattr(int fd, const char *name)
 #ifdef CONFIG_YAFFS_WINCE
 int yaffs_get_wince_times(int fd, unsigned *wctime, unsigned *watime, unsigned *wmtime)
 {
-	yaffs_Object *obj;
+	struct yaffs_obj *obj;
 
 	int retVal = -1;
 
 	yaffsfs_Lock();
-	obj = yaffsfs_GetHandleObject(fd);
+	obj = yaffsfs_HandleToObject(fd);
 
 	if(obj){
 
@@ -1568,25 +2159,25 @@ int yaffs_get_wince_times(int fd, unsigned *wctime, unsigned *watime, unsigned *
 		retVal = 0;
 	} else
 		/*  bad handle */
-		yaffsfs_SetError(-EBADF);		
-	
+		yaffsfs_SetError(-EBADF);
+
 	yaffsfs_Unlock();
-	
+
 	return retVal;
 }
 
 
-int yaffs_set_wince_times(int fd, 
-						  const unsigned *wctime, 
-						  const unsigned *watime, 
+int yaffs_set_wince_times(int fd,
+						  const unsigned *wctime,
+						  const unsigned *watime,
                                                   const unsigned *wmtime)
 {
-        yaffs_Object *obj;
+        struct yaffs_obj *obj;
         int result;
         int retVal = -1;
 
         yaffsfs_Lock();
-	obj = yaffsfs_GetHandleObject(fd);
+	obj = yaffsfs_HandleToObject(fd);
 
 	if(obj){
 
@@ -1604,7 +2195,7 @@ int yaffs_set_wince_times(int fd,
                 }
 
                 obj->dirty = 1;
-                result = yaffs_FlushFile(obj,0,0);
+                result = yaffs_flush_file(obj,0,0);
                 retVal = 0;
         } else
 		/* bad handle */
@@ -1618,17 +2209,17 @@ int yaffs_set_wince_times(int fd,
 #endif
 
 
-static int yaffsfs_DoChMod(yaffs_Object *obj,mode_t mode)
+static int yaffsfs_DoChMod(struct yaffs_obj *obj,mode_t mode)
 {
 	int result = -1;
 
 	if(obj)
-		obj = yaffs_GetEquivalentObject(obj);
+		obj = yaffs_get_equivalent_obj(obj);
 
 	if(obj) {
 		obj->yst_mode = mode;
 		obj->dirty = 1;
-		result = yaffs_FlushFile(obj,0,0);
+		result = yaffs_flush_file(obj,0,0);
 	}
 
 	return result == YAFFS_OK ? 0 : -1;
@@ -1637,15 +2228,41 @@ static int yaffsfs_DoChMod(yaffs_Object *obj,mode_t mode)
 
 int yaffs_access(const YCHAR *path, int amode)
 {
-	yaffs_Object *obj;
+	struct yaffs_obj *obj=NULL;
+	struct yaffs_obj *dir=NULL;
+	int notDir = 0;
+	int loop = 0;
+	int retval = -1;
+
+	if(!path){
+		yaffsfs_SetError(-EFAULT);
+		return -1;
+	}
 
-	int retval = 0;
+	if(yaffsfs_CheckPath(path) < 0){
+		yaffsfs_SetError(-ENAMETOOLONG);
+		return -1;
+	}
+
+	if(amode & ~(R_OK | W_OK | X_OK)){
+		yaffsfs_SetError(-EINVAL);
+		return -1;
+	}
 
 	yaffsfs_Lock();
 
-	obj = yaffsfs_FindObject(NULL,path,0,1);
+	obj = yaffsfs_FindObject(NULL,path,0,1, &dir,&notDir,&loop);
+	obj = yaffsfs_FollowLink(obj,0,&loop);
 
-	if(obj)	{
+	if(!dir && notDir)
+		yaffsfs_SetError(-ENOTDIR);
+	else if(loop)
+		yaffsfs_SetError(-ELOOP);
+	else if(!dir || !obj)
+		yaffsfs_SetError(-ENOENT);
+	else if((amode & W_OK) && obj->my_dev->read_only)
+		yaffsfs_SetError(-EROFS);
+	else{
 		int access_ok = 1;
 
 		if((amode & R_OK) && !(obj->yst_mode & S_IREAD))
@@ -1655,14 +2272,10 @@ int yaffs_access(const YCHAR *path, int amode)
 		if((amode & X_OK) && !(obj->yst_mode & S_IEXEC))
 			access_ok = 0;
 
-		if(!access_ok) {
+		if(!access_ok)
 			yaffsfs_SetError(-EACCES);
-			retval = -1;
-		}
-	} else {
-		/* todo error not found */
-		yaffsfs_SetError(-ENOENT);
-		retval = -1;
+		else
+			retval = 0;
 	}
 
 	yaffsfs_Unlock();
@@ -1674,18 +2287,40 @@ int yaffs_access(const YCHAR *path, int amode)
 
 int yaffs_chmod(const YCHAR *path, mode_t mode)
 {
-	yaffs_Object *obj;
-
+	struct yaffs_obj *obj=NULL;
+	struct yaffs_obj *dir=NULL;
 	int retVal = -1;
+	int notDir = 0;
+	int loop = 0;
+
+	if(!path){
+		yaffsfs_SetError(-EFAULT);
+		return -1;
+	}
+
+	if(yaffsfs_CheckPath(path) < 0){
+		yaffsfs_SetError(-ENAMETOOLONG);
+		return -1;
+	}
+
+	if(mode & ~(0777)){
+		yaffsfs_SetError(-EINVAL);
+		return -1;
+	}
 
 	yaffsfs_Lock();
 
-	obj = yaffsfs_FindObject(NULL,path,0,1);
+	obj = yaffsfs_FindObject(NULL,path,0,1, &dir, &notDir,&loop);
+	obj = yaffsfs_FollowLink(obj,0,&loop);
 
-	if(!obj)
+	if(!dir && notDir)
+		yaffsfs_SetError(-ENOTDIR);
+	else if(loop)
+		yaffsfs_SetError(-ELOOP);
+	else if(!dir || !obj)
 		yaffsfs_SetError(-ENOENT);
-	else if(obj->myDev->readOnly)
-		yaffsfs_SetError(-EINVAL);
+	else if(obj->my_dev->read_only)
+		yaffsfs_SetError(-EROFS);
 	else
 		retVal = yaffsfs_DoChMod(obj,mode);
 
@@ -1698,17 +2333,21 @@ int yaffs_chmod(const YCHAR *path, mode_t mode)
 
 int yaffs_fchmod(int fd, mode_t mode)
 {
-	yaffs_Object *obj;
-
+	struct yaffs_obj *obj;
 	int retVal = -1;
 
+	if(mode & ~(0777)){
+		yaffsfs_SetError(-EINVAL);
+		return -1;
+	}
+
 	yaffsfs_Lock();
-	obj = yaffsfs_GetHandleObject(fd);
+	obj = yaffsfs_HandleToObject(fd);
 
 	if(!obj)
-		yaffsfs_SetError(-ENOENT);
-	else if(obj->myDev->readOnly)
-		yaffsfs_SetError(-EINVAL);
+		yaffsfs_SetError(-EBADF);
+	else if(obj->my_dev->read_only)
+		yaffsfs_SetError(-EROFS);
 	else
 		retVal = yaffsfs_DoChMod(obj,mode);
 
@@ -1717,79 +2356,145 @@ int yaffs_fchmod(int fd, mode_t mode)
 	return retVal;
 }
 
-
 int yaffs_mkdir(const YCHAR *path, mode_t mode)
 {
-	yaffs_Object *parent = NULL;
-	yaffs_Object *dir = NULL;
+	struct yaffs_obj *parent = NULL;
+	struct yaffs_obj *dir = NULL;
 	YCHAR *name;
+	YCHAR *alt_path = NULL;
 	int retVal= -1;
+	int notDir = 0;
+	int loop = 0;
+
+	if(!path){
+		yaffsfs_SetError(-EFAULT);
+		return -1;
+	}
+
+	if(yaffsfs_CheckPath(path) < 0){
+		yaffsfs_SetError(-ENAMETOOLONG);
+		return -1;
+	}
+
+	if(yaffsfs_alt_dir_path(path, &alt_path) < 0){
+		yaffsfs_SetError(-ENOMEM);
+		return -1;
+	}
+	if(alt_path)
+		path = alt_path;
 
 	yaffsfs_Lock();
-	parent = yaffsfs_FindDirectory(NULL,path,&name,0);
-	if(parent && yaffs_strnlen(name,5) == 0){
+	parent = yaffsfs_FindDirectory(NULL,path,&name,0,&notDir,&loop);
+	if(!parent && notDir)
+		yaffsfs_SetError(-ENOTDIR);
+	else if(loop)
+		yaffsfs_SetError(-ELOOP);
+	else if(!parent)
+		yaffsfs_SetError(-ENOENT);
+	else if(yaffsfs_TooManyObjects(parent->my_dev))
+		yaffsfs_SetError(-ENFILE);
+	else if(yaffs_strnlen(name,5) == 0){
 		/* Trying to make the root itself */
 		yaffsfs_SetError(-EEXIST);
-	} else if(parent && parent->myDev->readOnly){
-		yaffsfs_SetError(-EINVAL);
-	} else {
-		if(parent)
-			dir = yaffs_MknodDirectory(parent,name,mode,0,0);
+	} else if(parent->my_dev->read_only)
+		yaffsfs_SetError(-EROFS);
+	else {
+		dir = yaffs_create_dir(parent,name,mode,0,0);
 		if(dir)
 			retVal = 0;
-		else {
-			if(!parent)
-				yaffsfs_SetError(-ENOENT); /* missing path */
-			else if (yaffs_FindObjectByName(parent,name))
-				yaffsfs_SetError(-EEXIST); /* the name already exists */
-			else
-				yaffsfs_SetError(-ENOSPC); /* just assume no space */
-			retVal = -1;
-		}
+		else if (yaffs_find_by_name(parent,name))
+			yaffsfs_SetError(-EEXIST); /* the name already exists */
+		else
+			yaffsfs_SetError(-ENOSPC); /* just assume no space */
 	}
 
 	yaffsfs_Unlock();
 
+	if(alt_path)
+		kfree(alt_path);
+
 	return retVal;
 }
 
+int yaffs_rmdir(const YCHAR *path)
+{
+	int result;
+	YCHAR *alt_path;
+
+	if(!path){
+		yaffsfs_SetError(-EFAULT);
+		return -1;
+	}
+
+	if(yaffsfs_CheckPath(path) < 0){
+		yaffsfs_SetError(-ENAMETOOLONG);
+		return -1;
+	}
+
+	if(yaffsfs_alt_dir_path(path, &alt_path) < 0){
+		yaffsfs_SetError(-ENOMEM);
+		return -1;
+	}
+	if(alt_path)
+		path = alt_path;
+	result =  yaffsfs_DoUnlink(path,1);
+	if(alt_path)
+		kfree(alt_path);
+	return result;
+}
+
+
 void * yaffs_getdev(const YCHAR *path)
 {
-	yaffs_Device *dev=NULL;
+	struct yaffs_dev *dev=NULL;
 	YCHAR *dummy;
 	dev = yaffsfs_FindDevice(path,&dummy);
 	return (void *)dev;
 }
 
-int yaffs_mount2(const YCHAR *path,int readOnly)
+int yaffs_mount_common(const YCHAR *path,int read_only, int skip_checkpt)
 {
 	int retVal=-1;
 	int result=YAFFS_FAIL;
-	yaffs_Device *dev=NULL;
-	YCHAR *dummy;
+	struct yaffs_dev *dev=NULL;
 
-	T(YAFFS_TRACE_ALWAYS,(TSTR("yaffs: Mounting %s" TENDSTR),path));
+	if(!path){
+		yaffsfs_SetError(-EFAULT);
+		return -1;
+	}
+
+	yaffs_trace(YAFFS_TRACE_MOUNT,"yaffs: Mounting %s",path);
+
+	if(yaffsfs_CheckPath(path) < 0){
+		yaffsfs_SetError(-ENAMETOOLONG);
+		return -1;
+	}
 
 	yaffsfs_Lock();
 
 	yaffsfs_InitHandles();
 
-	dev = yaffsfs_FindDevice(path,&dummy);
+	dev = yaffsfs_FindMountPoint(path);
 	if(dev){
-		if(!dev->isMounted){
-			dev->readOnly = readOnly ? 1 : 0;
-			result = yaffs_GutsInitialise(dev);
+		if(!dev->is_mounted){
+			dev->read_only = read_only ? 1 : 0;
+			if(skip_checkpt) {
+				u8 skip = dev->param.skip_checkpt_rd;
+				dev->param.skip_checkpt_rd = 1;
+				result = yaffs_guts_initialise(dev);
+				dev->param.skip_checkpt_rd = skip;
+			} else {
+				result = yaffs_guts_initialise(dev);
+			}
+
 			if(result == YAFFS_FAIL)
-				/* todo error - mount failed */
 				yaffsfs_SetError(-ENOMEM);
 			retVal = result ? 0 : -1;
 
 		}
 		else
-			/* todo error - already mounted. */
 			yaffsfs_SetError(-EBUSY);
 	} else
-		/* todo error - no device */
 		yaffsfs_SetError(-ENODEV);
 
 	yaffsfs_Unlock();
@@ -1797,63 +2502,92 @@ int yaffs_mount2(const YCHAR *path,int readOnly)
 
 }
 
+int yaffs_mount2(const YCHAR *path, int readonly)
+{
+	return yaffs_mount_common(path, readonly, 0);
+}
 int yaffs_mount(const YCHAR *path)
 {
-	return yaffs_mount2(path,0);
+	return yaffs_mount_common(path, 0, 0);
 }
 
 int yaffs_sync(const YCHAR *path)
 {
         int retVal=-1;
-        yaffs_Device *dev=NULL;
+        struct yaffs_dev *dev=NULL;
         YCHAR *dummy;
-        
+
+	if(!path){
+		yaffsfs_SetError(-EFAULT);
+		return -1;
+	}
+
+	if(yaffsfs_CheckPath(path) < 0){
+		yaffsfs_SetError(-ENAMETOOLONG);
+		return -1;
+	}
+
         yaffsfs_Lock();
         dev = yaffsfs_FindDevice(path,&dummy);
         if(dev){
-                if(dev->isMounted){
-                        
-                        yaffs_FlushEntireDeviceCache(dev);
-                        yaffs_CheckpointSave(dev);
+                if(!dev->is_mounted)
+			yaffsfs_SetError(-EINVAL);
+		else if(dev->read_only)
+			yaffsfs_SetError(-EROFS);
+		else {
+
+                        yaffs_flush_whole_cache(dev);
+                        yaffs_checkpoint_save(dev);
                         retVal = 0;
-                        
-                } else
-                        /* todo error - not mounted. */
-                        yaffsfs_SetError(-EINVAL);
-                        
+
+                }
         }else
-                /* todo error - no device */
                 yaffsfs_SetError(-ENODEV);
 
         yaffsfs_Unlock();
-        return retVal;  
+        return retVal;
+}
+
+
+static int yaffsfs_IsDevBusy(struct yaffs_dev * dev)
+{
+	int i;
+	struct yaffs_obj *obj;
+
+	for(i = 0; i < YAFFSFS_N_HANDLES; i++){
+		obj = yaffsfs_HandleToObject(i);
+		if(obj && obj->my_dev == dev)
+		return 1;
+	}
+	return 0;
 }
 
 
-int yaffs_remount(const YCHAR *path, int force, int readOnly)
+int yaffs_remount(const YCHAR *path, int force, int read_only)
 {
         int retVal=-1;
-	yaffs_Device *dev=NULL;
-	YCHAR *dummy;
+	struct yaffs_dev *dev=NULL;
 
-	yaffsfs_Lock();
-	dev = yaffsfs_FindDevice(path,&dummy);
-	if(dev){
-		if(dev->isMounted){
-			int i;
-			int inUse;
+	if(!path){
+		yaffsfs_SetError(-EFAULT);
+		return -1;
+	}
 
-			yaffs_FlushEntireDeviceCache(dev);
+	if(yaffsfs_CheckPath(path) < 0){
+		yaffsfs_SetError(-ENAMETOOLONG);
+		return -1;
+	}
 
-			for(i = inUse = 0; i < YAFFSFS_N_HANDLES && !inUse && !force; i++){
-				if(yaffsfs_handle[i].useCount>0 && yaffsfs_inode[yaffsfs_handle[i].inodeId].iObj->myDev == dev)
-					inUse = 1; /* the device is in use, can't unmount */
-			}
+	yaffsfs_Lock();
+	dev = yaffsfs_FindMountPoint(path);
+	if(dev){
+		if(dev->is_mounted){
+			yaffs_flush_whole_cache(dev);
 
-			if(!inUse || force){
-				if(readOnly)
-					yaffs_CheckpointSave(dev);
-				dev->readOnly =  readOnly ? 1 : 0;
+			if(force || ! yaffsfs_IsDevBusy(dev)){
+				if(read_only)
+					yaffs_checkpoint_save(dev);
+				dev->read_only =  read_only ? 1 : 0;
 				retVal = 0;
 			} else
 				yaffsfs_SetError(-EBUSY);
@@ -1873,39 +2607,39 @@ int yaffs_remount(const YCHAR *path, int force, int readOnly)
 int yaffs_unmount2(const YCHAR *path, int force)
 {
         int retVal=-1;
-	yaffs_Device *dev=NULL;
-	YCHAR *dummy;
+	struct yaffs_dev *dev=NULL;
+
+	if(!path){
+		yaffsfs_SetError(-EFAULT);
+		return -1;
+	}
+
+	if(yaffsfs_CheckPath(path) < 0){
+		yaffsfs_SetError(-ENAMETOOLONG);
+		return -1;
+	}
 
 	yaffsfs_Lock();
-	dev = yaffsfs_FindDevice(path,&dummy);
+	dev = yaffsfs_FindMountPoint(path);
 	if(dev){
-		if(dev->isMounted){
-			int i;
+		if(dev->is_mounted){
 			int inUse;
-
-			yaffs_FlushEntireDeviceCache(dev);
-			yaffs_CheckpointSave(dev);
-
-			for(i = inUse = 0; i < YAFFSFS_N_HANDLES && !inUse; i++){
-				if(yaffsfs_handle[i].useCount > 0 && yaffsfs_inode[yaffsfs_handle[i].inodeId].iObj->myDev == dev)
-					inUse = 1; /* the device is in use, can't unmount */
-			}
-
+			yaffs_flush_whole_cache(dev);
+			yaffs_checkpoint_save(dev);
+			inUse = yaffsfs_IsDevBusy(dev);
 			if(!inUse || force){
-				yaffs_Deinitialise(dev);
+				if(inUse)
+					yaffsfs_BreakDeviceHandles(dev);
+				yaffs_deinitialise(dev);
 
 				retVal = 0;
 			} else
-				/* todo error can't unmount as files are open */
 				yaffsfs_SetError(-EBUSY);
 
 		} else
-			/* todo error - not mounted. */
 			yaffsfs_SetError(-EINVAL);
 
-	}
-	else
-		/* todo error - no device */
+	} else
 		yaffsfs_SetError(-ENODEV);
 
 	yaffsfs_Unlock();
@@ -1921,14 +2655,24 @@ int yaffs_unmount(const YCHAR *path)
 loff_t yaffs_freespace(const YCHAR *path)
 {
 	loff_t retVal=-1;
-	yaffs_Device *dev=NULL;
+	struct yaffs_dev *dev=NULL;
 	YCHAR *dummy;
 
+	if(!path){
+		yaffsfs_SetError(-EFAULT);
+		return -1;
+	}
+
+	if(yaffsfs_CheckPath(path) < 0){
+		yaffsfs_SetError(-ENAMETOOLONG);
+		return -1;
+	}
+
 	yaffsfs_Lock();
 	dev = yaffsfs_FindDevice(path,&dummy);
-	if(dev  && dev->isMounted){
-		retVal = yaffs_GetNumberOfFreeChunks(dev);
-		retVal *= dev->nDataBytesPerChunk;
+	if(dev  && dev->is_mounted){
+		retVal = yaffs_get_n_free_chunks(dev);
+		retVal *= dev->data_bytes_per_chunk;
 
 	} else
 		yaffsfs_SetError(-EINVAL);
@@ -1940,15 +2684,26 @@ loff_t yaffs_freespace(const YCHAR *path)
 loff_t yaffs_totalspace(const YCHAR *path)
 {
 	loff_t retVal=-1;
-	yaffs_Device *dev=NULL;
+	struct yaffs_dev *dev=NULL;
 	YCHAR *dummy;
 
+	if(!path){
+		yaffsfs_SetError(-EFAULT);
+		return -1;
+	}
+
+	if(yaffsfs_CheckPath(path) < 0){
+		yaffsfs_SetError(-ENAMETOOLONG);
+		return -1;
+	}
+
 	yaffsfs_Lock();
 	dev = yaffsfs_FindDevice(path,&dummy);
-	if(dev  && dev->isMounted){
-		retVal = (dev->param.endBlock - dev->param.startBlock + 1) - dev->param.nReservedBlocks;
-		retVal *= dev->param.nChunksPerBlock;
-		retVal *= dev->nDataBytesPerChunk;
+	if(dev  && dev->is_mounted){
+		retVal = (dev->param.end_block - dev->param.start_block + 1) -
+			dev->param.n_reserved_blocks;
+		retVal *= dev->param.chunks_per_block;
+		retVal *= dev->data_bytes_per_chunk;
 
 	} else
 		yaffsfs_SetError(-EINVAL);
@@ -1960,39 +2715,57 @@ loff_t yaffs_totalspace(const YCHAR *path)
 int yaffs_inodecount(const YCHAR *path)
 {
 	loff_t retVal= -1;
-	yaffs_Device *dev=NULL;
+	struct yaffs_dev *dev=NULL;
 	YCHAR *dummy;
 
+	if(!path){
+		yaffsfs_SetError(-EFAULT);
+		return -1;
+	}
+
+	if(yaffsfs_CheckPath(path) < 0){
+		yaffsfs_SetError(-ENAMETOOLONG);
+		return -1;
+	}
+
 	yaffsfs_Lock();
 	dev = yaffsfs_FindDevice(path,&dummy);
-	if(dev  && dev->isMounted) {
-	   int nObjects = dev->nObjects;
-	   if(nObjects > dev->nHardLinks)
-		retVal = nObjects - dev->nHardLinks;
+	if(dev  && dev->is_mounted) {
+	   int n_obj = dev->n_obj;
+	   if(n_obj > dev->n_hardlinks)
+		retVal = n_obj - dev->n_hardlinks;
 	}
-	
+
 	if(retVal < 0)
 		yaffsfs_SetError(-EINVAL);
-	
+
 	yaffsfs_Unlock();
-	return retVal;	
+	return retVal;
 }
 
 
-void yaffs_AddDevice(yaffs_Device *dev)
+void yaffs_add_device(struct yaffs_dev *dev)
 {
-	dev->isMounted = 0;
-	dev->param.removeObjectCallback = yaffsfs_RemoveObjectCallback;
+	struct list_head *cfg;
+	/* First check that the device is not in the list. */
+
+	list_for_each(cfg, &yaffsfs_deviceList){
+		if(dev == list_entry(cfg, struct yaffs_dev, dev_list))
+			return;
+	}
+
+	dev->is_mounted = 0;
+	dev->param.remove_obj_fn = yaffsfs_RemoveObjectCallback;
 
-	if(!dev->devList.next)
-		YINIT_LIST_HEAD(&dev->devList);
+	if(!dev->dev_list.next)
+		INIT_LIST_HEAD(&dev->dev_list);
 
-	ylist_add(&dev->devList,&yaffsfs_deviceList);
+	list_add(&dev->dev_list,&yaffsfs_deviceList);
 }
 
-void yaffs_RemoveDevice(yaffs_Device *dev)
+void yaffs_remove_device(struct yaffs_dev *dev)
 {
-	ylist_del_init(&dev->devList);
+	list_del_init(&dev->dev_list);
 }
 
 
@@ -2009,33 +2782,33 @@ void yaffs_RemoveDevice(yaffs_Device *dev)
 
 typedef struct
 {
-	__u32 magic;
+	u32 magic;
 	yaffs_dirent de;		/* directory entry being used by this dsc */
 	YCHAR name[NAME_MAX+1];		/* name of directory being searched */
-        yaffs_Object *dirObj;           /* ptr to directory being searched */
-        yaffs_Object *nextReturn;       /* obj to be returned by next readddir */
+        struct yaffs_obj *dirObj;           /* ptr to directory being searched */
+        struct yaffs_obj *nextReturn;       /* obj to be returned by next readddir */
         int offset;
-        struct ylist_head others;       
+        struct list_head others;
 } yaffsfs_DirectorySearchContext;
 
 
 
-static struct ylist_head search_contexts;
+static struct list_head search_contexts;
 
 
 static void yaffsfs_SetDirRewound(yaffsfs_DirectorySearchContext *dsc)
 {
 	if(dsc &&
 	   dsc->dirObj &&
-	   dsc->dirObj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY){
+	   dsc->dirObj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY){
 
            dsc->offset = 0;
 
-           if( ylist_empty(&dsc->dirObj->variant.directoryVariant.children))
+           if( list_empty(&dsc->dirObj->variant.dir_variant.children))
                 dsc->nextReturn = NULL;
            else
-                dsc->nextReturn = ylist_entry(dsc->dirObj->variant.directoryVariant.children.next,
-                                                yaffs_Object,siblings);
+                dsc->nextReturn = list_entry(dsc->dirObj->variant.dir_variant.children.next,
+                                                struct yaffs_obj,siblings);
         } else {
 		/* Hey someone isn't playing nice! */
 	}
@@ -2045,28 +2818,28 @@ static void yaffsfs_DirAdvance(yaffsfs_DirectorySearchContext *dsc)
 {
 	if(dsc &&
 	   dsc->dirObj &&
-           dsc->dirObj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY){
+           dsc->dirObj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY){
 
            if( dsc->nextReturn == NULL ||
-               ylist_empty(&dsc->dirObj->variant.directoryVariant.children))
+               list_empty(&dsc->dirObj->variant.dir_variant.children))
                 dsc->nextReturn = NULL;
            else {
-                   struct ylist_head *next = dsc->nextReturn->siblings.next;
+                   struct list_head *next = dsc->nextReturn->siblings.next;
 
-                   if( next == &dsc->dirObj->variant.directoryVariant.children)
+                   if( next == &dsc->dirObj->variant.dir_variant.children)
                         dsc->nextReturn = NULL; /* end of list */
                    else
-                        dsc->nextReturn = ylist_entry(next,yaffs_Object,siblings);
+                        dsc->nextReturn = list_entry(next,struct yaffs_obj,siblings);
            }
         } else {
                 /* Hey someone isn't playing nice! */
 	}
 }
 
-static void yaffsfs_RemoveObjectCallback(yaffs_Object *obj)
+static void yaffsfs_RemoveObjectCallback(struct yaffs_obj *obj)
 {
 
-        struct ylist_head *i;
+        struct list_head *i;
         yaffsfs_DirectorySearchContext *dsc;
 
         /* if search contexts not initilised then skip */
@@ -2077,9 +2850,9 @@ static void yaffsfs_RemoveObjectCallback(yaffs_Object *obj)
          * If any are the one being removed, then advance the dsc to
          * the next one to prevent a hanging ptr.
          */
-         ylist_for_each(i, &search_contexts) {
+         list_for_each(i, &search_contexts) {
                 if (i) {
-                        dsc = ylist_entry(i, yaffsfs_DirectorySearchContext,others);
+                        dsc = list_entry(i, yaffsfs_DirectorySearchContext,others);
                         if(dsc->nextReturn == obj)
                                 yaffsfs_DirAdvance(dsc);
                 }
@@ -2090,16 +2863,36 @@ static void yaffsfs_RemoveObjectCallback(yaffs_Object *obj)
 yaffs_DIR *yaffs_opendir(const YCHAR *dirname)
 {
 	yaffs_DIR *dir = NULL;
- 	yaffs_Object *obj = NULL;
+ 	struct yaffs_obj *obj = NULL;
 	yaffsfs_DirectorySearchContext *dsc = NULL;
+	int notDir = 0;
+	int loop = 0;
+
+	if(!dirname){
+		yaffsfs_SetError(-EFAULT);
+		return NULL;
+	}
+
+	if(yaffsfs_CheckPath(dirname) < 0){
+		yaffsfs_SetError(-ENAMETOOLONG);
+		return NULL;
+	}
 
 	yaffsfs_Lock();
 
-	obj = yaffsfs_FindObject(NULL,dirname,0,1);
+	obj = yaffsfs_FindObject(NULL,dirname,0,1,NULL,&notDir,&loop);
 
-	if(obj && obj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY){
+	if(!obj && notDir)
+		yaffsfs_SetError(-ENOTDIR);
+	else if(loop)
+		yaffsfs_SetError(-ELOOP);
+	else if(!obj)
+		yaffsfs_SetError(-ENOENT);
+	else if(obj->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY)
+		yaffsfs_SetError(-ENOTDIR);
+	else {
 
-		dsc = YMALLOC(sizeof(yaffsfs_DirectorySearchContext));
+		dsc = kmalloc(sizeof(yaffsfs_DirectorySearchContext), 0);
 		dir = (yaffs_DIR *)dsc;
 
 		if(dsc){
@@ -2107,12 +2900,12 @@ yaffs_DIR *yaffs_opendir(const YCHAR *dirname)
                         dsc->magic = YAFFS_MAGIC;
                         dsc->dirObj = obj;
                         yaffs_strncpy(dsc->name,dirname,NAME_MAX);
-                        YINIT_LIST_HEAD(&dsc->others);
+                        INIT_LIST_HEAD(&dsc->others);
 
                         if(!search_contexts.next)
-                                YINIT_LIST_HEAD(&search_contexts);
+                                INIT_LIST_HEAD(&search_contexts);
 
-                        ylist_add(&dsc->others,&search_contexts);       
+                        list_add(&dsc->others,&search_contexts);
                         yaffsfs_SetDirRewound(dsc);
 		}
 
@@ -2133,10 +2926,10 @@ struct yaffs_dirent *yaffs_readdir(yaffs_DIR *dirp)
 	if(dsc && dsc->magic == YAFFS_MAGIC){
 		yaffsfs_SetError(0);
 		if(dsc->nextReturn){
-			dsc->de.d_ino = yaffs_GetEquivalentObject(dsc->nextReturn)->objectId;
+			dsc->de.d_ino = yaffs_get_equivalent_obj(dsc->nextReturn)->obj_id;
 			dsc->de.d_dont_use = (unsigned)dsc->nextReturn;
 			dsc->de.d_off = dsc->offset++;
-			yaffs_GetObjectName(dsc->nextReturn,dsc->de.d_name,NAME_MAX);
+			yaffs_get_obj_name(dsc->nextReturn,dsc->de.d_name,NAME_MAX);
 			if(yaffs_strnlen(dsc->de.d_name,NAME_MAX+1) == 0)
 			{
 				/* this should not happen! */
@@ -2173,10 +2966,15 @@ int yaffs_closedir(yaffs_DIR *dirp)
 {
 	yaffsfs_DirectorySearchContext *dsc = (yaffsfs_DirectorySearchContext *)dirp;
 
+	if(!dsc){
+		yaffsfs_SetError(-EFAULT);
+		return -1;
+	}
+
         yaffsfs_Lock();
         dsc->magic = 0;
-        ylist_del(&dsc->others); /* unhook from list */
-        YFREE(dsc);
+        list_del(&dsc->others); /* unhook from list */
+        kfree(dsc);
         yaffsfs_Unlock();
         return 0;
 }
@@ -2186,27 +2984,45 @@ int yaffs_closedir(yaffs_DIR *dirp)
 
 int yaffs_symlink(const YCHAR *oldpath, const YCHAR *newpath)
 {
-	yaffs_Object *parent = NULL;
-	yaffs_Object *obj;
+	struct yaffs_obj *parent = NULL;
+	struct yaffs_obj *obj;
 	YCHAR *name;
 	int retVal= -1;
 	int mode = 0; /* ignore for now */
+	int notDir = 0;
+	int loop = 0;
+
+	if(!oldpath || !newpath){
+		yaffsfs_SetError(-EFAULT);
+		return -1;
+	}
+
+	if(yaffsfs_CheckPath(newpath) < 0 ||
+		yaffsfs_CheckPath(oldpath) < 0){
+		yaffsfs_SetError(-ENAMETOOLONG);
+		return -1;
+	}
 
 	yaffsfs_Lock();
-	parent = yaffsfs_FindDirectory(NULL,newpath,&name,0);
-	if(parent && parent->myDev->readOnly)
-		yaffsfs_SetError(-EINVAL);
+	parent = yaffsfs_FindDirectory(NULL,newpath,&name,0,&notDir,&loop);
+	if(!parent && notDir)
+		yaffsfs_SetError(-ENOTDIR);
+	else if(loop)
+		yaffsfs_SetError(-ELOOP);
+	else if( !parent || yaffs_strnlen(name,5) < 1)
+		yaffsfs_SetError(-ENOENT);
+	else if(yaffsfs_TooManyObjects(parent->my_dev))
+		yaffsfs_SetError(-ENFILE);
+	else if(parent->my_dev->read_only)
+		yaffsfs_SetError(-EROFS);
 	else if(parent){
-		obj = yaffs_MknodSymLink(parent,name,mode,0,0,oldpath);
+		obj = yaffs_create_symlink(parent,name,mode,0,0,oldpath);
 		if(obj)
 			retVal = 0;
-		else{
-			yaffsfs_SetError(-ENOSPC); /* just assume no space for now */
-			retVal = -1;
-		}
-	} else {
-		yaffsfs_SetError(-EINVAL);
-		retVal = -1;
+		else if (yaffsfs_FindObject(NULL,newpath,0,0, NULL,NULL,NULL))
+			yaffsfs_SetError(-EEXIST);
+		else
+			yaffsfs_SetError(-ENOSPC);
 	}
 
 	yaffsfs_Unlock();
@@ -2217,22 +3033,31 @@ int yaffs_symlink(const YCHAR *oldpath, const YCHAR *newpath)
 
 int yaffs_readlink(const YCHAR *path, YCHAR *buf, int bufsiz)
 {
-	yaffs_Object *obj = NULL;
-	int retVal;
+	struct yaffs_obj *obj = NULL;
+	struct yaffs_obj *dir = NULL;
+	int retVal= -1;
+	int notDir = 0;
+	int loop = 0;
 
+	if(!path || !buf){
+		yaffsfs_SetError(-EFAULT);
+		return -1;
+	}
 
 	yaffsfs_Lock();
 
-	obj = yaffsfs_FindObject(NULL,path,0,1);
+	obj = yaffsfs_FindObject(NULL,path,0,1, &dir,&notDir,&loop);
 
-	if(!obj) {
+	if(!dir && notDir)
+		yaffsfs_SetError(-ENOTDIR);
+	else if(loop)
+		yaffsfs_SetError(-ELOOP);
+	else if(!dir || !obj)
 		yaffsfs_SetError(-ENOENT);
-		retVal = -1;
-	} else if(obj->variantType != YAFFS_OBJECT_TYPE_SYMLINK) {
+	else if(obj->variant_type != YAFFS_OBJECT_TYPE_SYMLINK)
 		yaffsfs_SetError(-EINVAL);
-		retVal = -1;
-	} else {
-		YCHAR *alias = obj->variant.symLinkVariant.alias;
+	else {
+		YCHAR *alias = obj->variant.symlink_variant.alias;
 		memset(buf,0,bufsiz);
 		yaffs_strncpy(buf,alias,bufsiz - 1);
 		retVal = 0;
@@ -2241,64 +3066,62 @@ int yaffs_readlink(const YCHAR *path, YCHAR *buf, int bufsiz)
 	return retVal;
 }
 
-int yaffs_link(const YCHAR *oldpath, const YCHAR *newpath)
+int yaffs_link(const YCHAR *oldpath, const YCHAR *linkpath)
 {
 	/* Creates a link called newpath to existing oldpath */
-	yaffs_Object *obj = NULL;
-	yaffs_Object *target = NULL;
-	int retVal = 0;
-	int newNameLength = 0;
+	struct yaffs_obj *obj = NULL;
+	struct yaffs_obj *lnk = NULL;
+	struct yaffs_obj *obj_dir = NULL;
+	struct yaffs_obj *lnk_dir = NULL;
+	int retVal = -1;
+	int notDirObj = 0;
+	int notDirLnk = 0;
+	int objLoop = 0;
+	int lnkLoop = 0;
+	YCHAR *newname;
+
+	if(!oldpath || !linkpath){
+		yaffsfs_SetError(-EFAULT);
+		return -1;
+	}
 
+	if(yaffsfs_CheckPath(linkpath) < 0 ||
+		yaffsfs_CheckPath(oldpath) < 0){
+		yaffsfs_SetError(-ENAMETOOLONG);
+		return -1;
+	}
 
 	yaffsfs_Lock();
 
-	obj = yaffsfs_FindObject(NULL,oldpath,0,1);
-	target = yaffsfs_FindObject(NULL,newpath,0,0);
+	obj = yaffsfs_FindObject(NULL,oldpath,0,1,&obj_dir,&notDirObj,&objLoop);
+	lnk = yaffsfs_FindObject(NULL,linkpath,0,0,NULL,NULL,NULL);
+	lnk_dir = yaffsfs_FindDirectory(NULL,linkpath,&newname,0,&notDirLnk,&lnkLoop);
 
-	if(!obj) {
+	if((!obj_dir && notDirObj) || (!lnk_dir && notDirLnk))
+		yaffsfs_SetError(-ENOTDIR);
+	else if(objLoop || lnkLoop)
+		yaffsfs_SetError(-ELOOP);
+	else if(!obj_dir || !lnk_dir || !obj)
 		yaffsfs_SetError(-ENOENT);
-		retVal = -1;
-	} else if(obj->myDev->readOnly){
-		yaffsfs_SetError(-EINVAL);
-		retVal= -1;
-	} else if(target) {
+	else if(obj->my_dev->read_only)
+		yaffsfs_SetError(-EROFS);
+	else if(yaffsfs_TooManyObjects(obj->my_dev))
+		yaffsfs_SetError(-ENFILE);
+	else if(lnk)
 		yaffsfs_SetError(-EEXIST);
-		retVal = -1;
-	} else {
-		yaffs_Object *newdir = NULL;
-		yaffs_Object *link = NULL;
-
-		YCHAR *newname;
-
-		newdir = yaffsfs_FindDirectory(NULL,newpath,&newname,0);
+	else if(lnk_dir->my_dev != obj->my_dev)
+		yaffsfs_SetError(-EXDEV);
+	else {
+		retVal = yaffsfs_CheckNameLength(newname);
 
-		if(!newdir){
-			yaffsfs_SetError(-ENOTDIR);
-			retVal = -1;
-		}else if(newdir->myDev != obj->myDev){
-			yaffsfs_SetError(-EXDEV);
-			retVal = -1;
-		}
-		
-		newNameLength = yaffs_strnlen(newname,YAFFS_MAX_NAME_LENGTH+1);
-		
-		if(newNameLength == 0){
-			yaffsfs_SetError(-ENOENT);
-			retVal = -1;
-		} else if (newNameLength > YAFFS_MAX_NAME_LENGTH){
-			yaffsfs_SetError(-ENAMETOOLONG);
-			retVal = -1;
-		}
-		
 		if(retVal == 0) {
-			link = yaffs_Link(newdir,newname,obj);
-			if(link)
+			lnk = yaffs_link_obj(lnk_dir,newname,obj);
+			if(lnk)
 				retVal = 0;
 			else{
 				yaffsfs_SetError(-ENOSPC);
 				retVal = -1;
 			}
-
 		}
 	}
 	yaffsfs_Unlock();
@@ -2308,10 +3131,18 @@ int yaffs_link(const YCHAR *oldpath, const YCHAR *newpath)
 
 int yaffs_mknod(const YCHAR *pathname, mode_t mode, dev_t dev)
 {
+	pathname=pathname;
+	mode=mode;
+	dev=dev;
+
+	yaffsfs_SetError(-EINVAL);
 	return -1;
 }
 
 
+/*
+ * D E B U G   F U N C T I O N S
+ */
 
 /*
  * yaffs_n_handles()
@@ -2319,35 +3150,61 @@ int yaffs_mknod(const YCHAR *pathname, mode_t mode, dev_t dev)
  */
 int yaffs_n_handles(const YCHAR *path)
 {
-	yaffs_Object *obj;
+	struct yaffs_obj *obj;
+
+	if(!path){
+		yaffsfs_SetError(-EFAULT);
+		return -1;
+	}
+
+	if(yaffsfs_CheckPath(path) < 0){
+		yaffsfs_SetError(-ENAMETOOLONG);
+		return -1;
+	}
+
+	obj = yaffsfs_FindObject(NULL,path,0,1,NULL,NULL,NULL);
+
+	if(obj)
+		return yaffsfs_CountHandles(obj);
+	else
+		return -1;
+}
 
-	obj = yaffsfs_FindObject(NULL,path,0,1);
+int yaffs_get_error(void)
+{
+	return yaffsfs_GetLastError();
+}
 
-	return yaffsfs_CountHandles(obj);
+int yaffs_set_error(int error)
+{
+	yaffsfs_SetError(error);
+	return 0;
 }
 
-int yaffs_DumpDevStruct(const YCHAR *path)
+int yaffs_dump_dev(const YCHAR *path)
 {
-#if 0
+#if 1
+	path=path;
+#else
 	YCHAR *rest;
 
-	yaffs_Object *obj = yaffsfs_FindRoot(path,&rest);
+	struct yaffs_obj *obj = yaffsfs_FindRoot(path,&rest);
 
 	if(obj){
-		yaffs_Device *dev = obj->myDev;
+		struct yaffs_dev *dev = obj->my_dev;
 
 		printf("\n"
-			   "nPageWrites.......... %d\n"
-			   "nPageReads........... %d\n"
-			   "nBlockErasures....... %d\n"
-			   "nGCCopies............ %d\n"
+			   "n_page_writes.......... %d\n"
+			   "n_page_reads........... %d\n"
+			   "n_erasures....... %d\n"
+			   "n_gc_copies............ %d\n"
 			   "garbageCollections... %d\n"
 			   "passiveGarbageColl'ns %d\n"
 			   "\n",
-				dev->nPageWrites,
-				dev->nPageReads,
-				dev->nBlockErasures,
-				dev->nGCCopies,
+				dev->n_page_writes,
+				dev->n_page_reads,
+				dev->n_erasures,
+				dev->n_gc_copies,
 				dev->garbageCollections,
 				dev->passiveGarbageCollections
 		);