X-Git-Url: http://www.aleph1.co.uk/gitweb/?p=yaffs2.git;a=blobdiff_plain;f=direct%2Fyaffsfs.c;h=3cb11a92a3c4675ec4220cad03e4378625168ec1;hp=a26998439ccefd2f0d4fe6b2119c15e65dee3cf1;hb=d13e6146b4ccadd7aab2033b6cf9f4551d6abd71;hpb=93e9fdf712264bc18bad8b249e8e908494b0f774

diff --git a/direct/yaffsfs.c b/direct/yaffsfs.c
index a269984..3cb11a9 100644
--- a/direct/yaffsfs.c
+++ b/direct/yaffsfs.c
@@ -25,6 +25,8 @@
 #define NULL ((void *)0)
 #endif
 
+#define ROOT_DIR(dev) (((dev) && (dev)->is_mounted) ? (dev)->root_dir : NULL)
+
 /* YAFFSFS_RW_SIZE must be a power of 2 */
 #define YAFFSFS_RW_SHIFT (13)
 #define YAFFSFS_RW_SIZE  (1<<YAFFSFS_RW_SHIFT)
@@ -37,6 +39,9 @@ static struct yaffs_obj *yaffsfs_FindObject(struct yaffs_obj *relativeDirectory,
 					    int *notDir, int *loop);
 
 static void yaffsfs_RemoveObjectCallback(struct yaffs_obj *obj);
+static yaffs_DIR *yaffsfs_opendir_reldir_no_lock(
+				struct yaffs_obj *reldir, const YCHAR *dirname);
+static int yaffsfs_closedir_no_lock(yaffs_DIR *dirent);
 
 unsigned int yaffs_wr_attempts;
 
@@ -66,15 +71,30 @@ struct yaffsfs_Inode {
 	struct yaffs_obj *iObj;
 };
 
+
+struct yaffsfs_DirSearchContext {
+	struct yaffs_dirent de;	/* directory entry */
+	YCHAR name[NAME_MAX + 1];	/* name of directory being searched */
+	struct yaffs_obj *dirObj;	/* ptr to directory being searched */
+	struct yaffs_obj *nextReturn;	/* obj  returned by next readddir */
+	struct list_head others;
+	s32 offset:20;
+	u8 inUse:1;
+};
+
 struct yaffsfs_FileDes {
+	u8 isDir:1; 		/* This s a directory */
 	u8 reading:1;
 	u8 writing:1;
 	u8 append:1;
 	u8 shareRead:1;
 	u8 shareWrite:1;
-	int inodeId:12;		/* Index to corresponding yaffsfs_Inode */
-	int handleCount:10;	/* Number of handles for this fd */
-	Y_LOFF_T position;	/* current position in file */
+	s32 inodeId:12;		/* Index to corresponding yaffsfs_Inode */
+	s32 handleCount:10;	/* Number of handles for this fd */
+	union {
+		Y_LOFF_T position;	/* current position in file */
+		yaffs_DIR *dir;
+	} v;
 };
 
 struct yaffsfs_Handle {
@@ -83,17 +103,7 @@ struct yaffsfs_Handle {
 };
 
 
-struct yaffsfs_DirSearchContxt {
-	struct yaffs_dirent de;	/* directory entry */
-	YCHAR name[NAME_MAX + 1];	/* name of directory being searched */
-	struct yaffs_obj *dirObj;	/* ptr to directory being searched */
-	struct yaffs_obj *nextReturn;	/* obj  returned by next readddir */
-	struct list_head others;
-	int offset:20;
-	unsigned inUse:1;
-};
-
-static struct yaffsfs_DirSearchContxt yaffsfs_dsc[YAFFSFS_N_DSC];
+static struct yaffsfs_DirSearchContext yaffsfs_dsc[YAFFSFS_N_DSC];
 static struct yaffsfs_Inode yaffsfs_inode[YAFFSFS_N_HANDLES];
 static struct yaffsfs_FileDes yaffsfs_fd[YAFFSFS_N_HANDLES];
 static struct yaffsfs_Handle yaffsfs_handle[YAFFSFS_N_HANDLES];
@@ -119,6 +129,7 @@ unsigned yaffs_get_trace(void)
 static void yaffsfs_InitHandles(void)
 {
 	int i;
+
 	if (yaffsfs_handlesInitialised)
 		return;
 
@@ -240,13 +251,11 @@ static void yaffsfs_ReleaseInode(struct yaffsfs_Inode *in)
 	struct yaffs_obj *obj;
 
 	obj = in->iObj;
-
-	if (obj->unlinked)
-		yaffs_del_obj(obj);
-
 	obj->my_inode = NULL;
 	in->iObj = NULL;
 
+	if (obj->unlinked)
+		yaffs_del_obj(obj);
 }
 
 static void yaffsfs_PutInode(int inodeId)
@@ -337,6 +346,10 @@ static int yaffsfs_PutFileDes(int fdId)
 		fd = &yaffsfs_fd[fdId];
 		fd->handleCount--;
 		if (fd->handleCount < 1) {
+			if (fd->isDir) {
+				yaffsfs_closedir_no_lock(fd->v.dir);
+				fd->v.dir = NULL;
+			}
 			if (fd->inodeId >= 0) {
 				yaffsfs_PutInode(fd->inodeId);
 				fd->inodeId = -1;
@@ -387,7 +400,7 @@ static void yaffsfs_BreakDeviceHandles(struct yaffs_dev *dev)
  *  Stuff to handle names.
  */
 #ifdef CONFIG_YAFFS_CASE_INSENSITIVE
-
+#ifndef CONFIG_YAFFS_WINCE
 static int yaffs_toupper(YCHAR a)
 {
 	if (a >= 'a' && a <= 'z')
@@ -395,6 +408,7 @@ static int yaffs_toupper(YCHAR a)
 	else
 		return a;
 }
+#endif
 
 static int yaffsfs_Match(YCHAR a, YCHAR b)
 {
@@ -421,7 +435,7 @@ static int yaffsfs_IsPathDivider(YCHAR ch)
 	return 0;
 }
 
-static int yaffsfs_CheckNameLength(const char *name)
+static int yaffsfs_CheckNameLength(const YCHAR *name)
 {
 	int retVal = 0;
 
@@ -503,17 +517,17 @@ static struct yaffs_dev *yaffsfs_FindDevice(const YCHAR *path,
 		thisMatchLength = 0;
 		matching = 1;
 
+
 		if(!p)
 			continue;
 
-		while (matching && *p && *leftOver) {
-			/* Skip over any /s */
-			while (yaffsfs_IsPathDivider(*p))
-				p++;
+		/* Skip over any leading  /s */
+		while (yaffsfs_IsPathDivider(*p))
+			p++;
+		while (yaffsfs_IsPathDivider(*leftOver))
+			leftOver++;
 
-			/* Skip over any /s */
-			while (yaffsfs_IsPathDivider(*leftOver))
-				leftOver++;
+		while (matching && *p && *leftOver) {
 
 			/* Now match the text part */
 			while (matching &&
@@ -527,6 +541,16 @@ static struct yaffs_dev *yaffsfs_FindDevice(const YCHAR *path,
 					matching = 0;
 				}
 			}
+
+			if ((*p && !yaffsfs_IsPathDivider(*p)) ||
+			    (*leftOver && !yaffsfs_IsPathDivider(*leftOver)))
+				matching = 0;
+			else {
+				while (yaffsfs_IsPathDivider(*p))
+					p++;
+				while (yaffsfs_IsPathDivider(*leftOver))
+					leftOver++;
+			}
 		}
 
 		/* Skip over any /s in leftOver */
@@ -547,7 +571,6 @@ static struct yaffs_dev *yaffsfs_FindDevice(const YCHAR *path,
 			retval = dev;
 			longestMatch = thisMatchLength;
 		}
-
 	}
 	return retval;
 }
@@ -604,7 +627,10 @@ static struct yaffs_obj *yaffsfs_FollowLink(struct yaffs_obj *obj,
 		YCHAR *alias = obj->variant.symlink_variant.alias;
 
 		if (yaffsfs_IsPathDivider(*alias))
-			/* Starts with a /, need to scan from root up */
+			/*
+			 * Starts with a /, need to scan from root up */
+			/* NB Might not work if this is called with root != NULL
+			*/
 			obj = yaffsfs_FindObject(NULL, alias, symDepth++,
 						 1, NULL, NULL, loop);
 		else
@@ -723,7 +749,20 @@ static struct yaffs_obj *yaffsfs_FindObject(struct yaffs_obj *relDir,
 	if (dirOut)
 		*dirOut = dir;
 
-	if (dir && *name)
+	/* At this stage we have looked up directory part and have the name part
+	 * in name if there is one.
+	 *
+	 *  eg /nand/x/ will give us a name of ""
+	 *     /nand/x will give us a name of "x"
+	 *
+	 * Since the name part might be "." or ".." which need to be fixed.
+	 */
+	if (dir && (yaffs_strcmp(name, _Y("..")) == 0)) {
+		dir = dir->parent;
+		obj = dir;
+	} else if (dir && (yaffs_strcmp(name, _Y(".")) == 0))
+		obj = dir;
+	else if (dir && *name)
 		obj = yaffs_find_by_name(dir, name);
 	else
 		obj = dir;
@@ -776,7 +815,8 @@ static int yaffsfs_TooManyObjects(struct yaffs_dev *dev)
 		return 0;
 }
 
-int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing)
+int yaffs_open_sharing_reldir(struct yaffs_obj *reldir, const YCHAR *path,
+			int oflag, int mode, int sharing)
 {
 	struct yaffs_obj *obj = NULL;
 	struct yaffs_obj *dir = NULL;
@@ -797,6 +837,8 @@ int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing)
 	u8 writeRequested;
 	int notDir = 0;
 	int loop = 0;
+	int is_dir = 0;
+	yaffs_DIR *dsc = NULL;
 
 	if (yaffsfs_CheckMemRegion(path, 0, 0)< 0) {
 		yaffsfs_SetError(-EFAULT);
@@ -813,7 +855,7 @@ int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing)
 		oflag &= ~(O_EXCL);
 
 	/* O_TRUNC has no meaning if (O_CREAT | O_EXCL) is specified */
-	if ((oflag & O_CREAT) & (oflag & O_EXCL))
+	if ((oflag & O_CREAT) && (oflag & O_EXCL))
 		oflag &= ~(O_TRUNC);
 
 	/* Todo: Are there any more flag combos to sanitise ? */
@@ -829,13 +871,13 @@ int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing)
 
 	if (handle < 0) {
 		yaffsfs_SetError(-ENFILE);
-		errorReported = 1;
+		errorReported = __LINE__;
 	} else {
 
 		fd = yaffsfs_HandleToFileDes(handle);
 
 		/* try to find the exisiting object */
-		obj = yaffsfs_FindObject(NULL, path, 0, 1, NULL, NULL, NULL);
+		obj = yaffsfs_FindObject(reldir, path, 0, 1, NULL, NULL, NULL);
 
 		obj = yaffsfs_FollowLink(obj, symDepth++, &loop);
 
@@ -847,12 +889,24 @@ int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing)
 		if (obj) {
 
 			/* The file already exists or it might be a directory */
+			is_dir = (obj->variant_type ==
+					YAFFS_OBJECT_TYPE_DIRECTORY);
 
-			/* A directory can't be opened as a file */
-			if (obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) {
-				openDenied = 1;
+			/* A directory can't be opened except for read */
+			if ( is_dir &&
+			    (writeRequested || !readRequested || rwflags != O_RDONLY)) {
+				openDenied = __LINE__;
 				yaffsfs_SetError(-EISDIR);
-				errorReported = 1;
+				errorReported = __LINE__;
+			}
+
+			if(is_dir) {
+				dsc = yaffsfs_opendir_reldir_no_lock(reldir, path);
+				if (!dsc) {
+					openDenied = __LINE__;
+					yaffsfs_SetError(-ENFILE);
+					errorReported = __LINE__;
+				}
 			}
 
 			/* Open should fail if O_CREAT and O_EXCL are specified
@@ -860,28 +914,28 @@ int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing)
 			 */
 			if (!errorReported &&
 			    (oflag & O_EXCL) && (oflag & O_CREAT)) {
-				openDenied = 1;
+				openDenied = __LINE__;
 				yaffsfs_SetError(-EEXIST);
-				errorReported = 1;
+				errorReported = __LINE__;
 			}
 
 			/* Check file permissions */
-			if (readRequested && !(obj->yst_mode & S_IREAD))
-				openDenied = 1;
+			if (readRequested && !(obj->yst_mode & S_IRUSR))
+				openDenied = __LINE__;
 
-			if (writeRequested && !(obj->yst_mode & S_IWRITE))
-				openDenied = 1;
+			if (writeRequested && !(obj->yst_mode & S_IWUSR))
+				openDenied = __LINE__;
 
 			if (!errorReported && writeRequested &&
 			    obj->my_dev->read_only) {
-				openDenied = 1;
+				openDenied = __LINE__;
 				yaffsfs_SetError(-EROFS);
-				errorReported = 1;
+				errorReported = __LINE__;
 			}
 
 			if (openDenied && !errorReported) {
 				yaffsfs_SetError(-EACCES);
-				errorReported = 1;
+				errorReported = __LINE__;
 			}
 
 			/* Check sharing of an existing object. */
@@ -914,9 +968,9 @@ int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing)
 				    (!shareRead && alreadyReading) ||
 				    (!sharedWriteAllowed && writeRequested) ||
 				    (!shareWrite && alreadyWriting)) {
-					openDenied = 1;
+					openDenied = __LINE__;
 					yaffsfs_SetError(-EBUSY);
-					errorReported = 1;
+					errorReported = __LINE__;
 				}
 			}
 
@@ -926,17 +980,17 @@ int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing)
 		 * the directory exists. If not, error.
 		 */
 		if (!obj && !errorReported) {
-			dir = yaffsfs_FindDirectory(NULL, path, &name, 0,
+			dir = yaffsfs_FindDirectory(reldir, path, &name, 0,
 						    &notDir, &loop);
 			if (!dir && notDir) {
 				yaffsfs_SetError(-ENOTDIR);
-				errorReported = 1;
+				errorReported = __LINE__;
 			} else if (loop) {
 				yaffsfs_SetError(-ELOOP);
-				errorReported = 1;
+				errorReported = __LINE__;
 			} else if (!dir) {
 				yaffsfs_SetError(-ENOENT);
-				errorReported = 1;
+				errorReported = __LINE__;
 			}
 		}
 
@@ -944,22 +998,22 @@ int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing)
 			/* Let's see if we can create this file */
 			if (dir->my_dev->read_only) {
 				yaffsfs_SetError(-EROFS);
-				errorReported = 1;
+				errorReported = __LINE__;
 			} else if (yaffsfs_TooManyObjects(dir->my_dev)) {
 				yaffsfs_SetError(-ENFILE);
-				errorReported = 1;
+				errorReported = __LINE__;
 			} else
 				obj = yaffs_create_file(dir, name, mode, 0, 0);
 
 			if (!obj && !errorReported) {
 				yaffsfs_SetError(-ENOSPC);
-				errorReported = 1;
+				errorReported = __LINE__;
 			}
 		}
 
 		if (!obj && dir && !errorReported && !(oflag & O_CREAT)) {
 			yaffsfs_SetError(-ENOENT);
-			errorReported = 1;
+			errorReported = __LINE__;
 		}
 
 		if (obj && !openDenied) {
@@ -977,16 +1031,24 @@ int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing)
 			fd->reading = readRequested;
 			fd->writing = writeRequested;
 			fd->append = (oflag & O_APPEND) ? 1 : 0;
-			fd->position = 0;
 			fd->shareRead = shareRead;
 			fd->shareWrite = shareWrite;
+			fd->isDir = is_dir;
+
+			if(is_dir)
+				fd->v.dir = dsc;
+			else
+				fd->v.position = 0;
 
 			/* Hook inode to object */
 			obj->my_inode = (void *)&yaffsfs_inode[inodeId];
 
-			if ((oflag & O_TRUNC) && fd->writing)
+			if (!is_dir && (oflag & O_TRUNC) && fd->writing)
 				yaffs_resize_file(obj, 0);
 		} else {
+			if (dsc)
+				yaffsfs_closedir_no_lock(dsc);
+			dsc = NULL;
 			yaffsfs_PutHandle(handle);
 			if (!errorReported)
 				yaffsfs_SetError(0);	/* Problem */
@@ -999,12 +1061,35 @@ int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing)
 	return handle;
 }
 
-int yaffs_open(const YCHAR *path, int oflag, int mode)
+int yaffs_open_sharing_reldev(struct yaffs_dev *dev, const YCHAR *path, int oflag,
+				int mode, int sharing)
+{
+	return yaffs_open_sharing_reldir(ROOT_DIR(dev), path,
+					oflag, mode, sharing);
+}
+
+int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing)
+{
+	return yaffs_open_sharing_reldir(NULL, path, oflag, mode, sharing);
+}
+
+int yaffs_open_reldir(struct yaffs_obj *reldir,const YCHAR *path, int oflag, int mode)
+{
+	return yaffs_open_sharing_reldir(reldir, path, oflag, mode,
+				  YAFFS_SHARE_READ | YAFFS_SHARE_WRITE);
+}
+
+int yaffs_open_reldev(struct yaffs_dev *dev,const YCHAR *path, int oflag, int mode)
 {
-	return yaffs_open_sharing(path, oflag, mode,
+	return yaffs_open_sharing_reldir(ROOT_DIR(dev), path, oflag, mode,
 				  YAFFS_SHARE_READ | YAFFS_SHARE_WRITE);
 }
 
+int yaffs_open(const YCHAR *path, int oflag, int mode)
+{
+	return yaffs_open_reldir(NULL, path, oflag, mode);
+}
+
 static int yaffs_Dofsync(int handle, int datasync)
 {
 	int retVal = -1;
@@ -1019,7 +1104,7 @@ static int yaffs_Dofsync(int handle, int datasync)
 	else if (obj->my_dev->read_only)
 		yaffsfs_SetError(-EROFS);
 	else {
-		yaffs_flush_file(obj, 1, datasync);
+		yaffs_flush_file(obj, 1, datasync, 0);
 		retVal = 0;
 	}
 
@@ -1046,19 +1131,22 @@ int yaffs_fdatasync(int handle)
 int yaffs_close(int handle)
 {
 	struct yaffsfs_Handle *h = NULL;
+	struct yaffsfs_FileDes *f;
 	struct yaffs_obj *obj = NULL;
 	int retVal = -1;
 
 	yaffsfs_Lock();
 
 	h = yaffsfs_HandleToPointer(handle);
+	f = yaffsfs_HandleToFileDes(handle);
 	obj = yaffsfs_HandleToObject(handle);
 
-	if (!h || !obj)
+	if (!h || !obj || !f)
 		yaffsfs_SetError(-EBADF);
 	else {
 		/* clean up */
-		yaffs_flush_file(obj, 1, 0);
+		if(!f->isDir)
+			yaffs_flush_file(obj, 1, 0, 1);
 		yaffsfs_PutHandle(handle);
 		retVal = 0;
 	}
@@ -1106,7 +1194,7 @@ static int yaffsfs_do_read(int handle, void *vbuf, unsigned int nbyte,
 		if (isPread)
 			startPos = offset;
 		else
-			startPos = fd->position;
+			startPos = fd->v.position;
 
 		pos = startPos;
 
@@ -1167,7 +1255,7 @@ static int yaffsfs_do_read(int handle, void *vbuf, unsigned int nbyte,
 
 		if (!isPread) {
 			if (totalRead >= 0)
-				fd->position = startPos + totalRead;
+				fd->v.position = startPos + totalRead;
 			else
 				yaffsfs_SetError(-EINVAL);
 		}
@@ -1229,7 +1317,7 @@ static int yaffsfs_do_write(int handle, const void *vbuf, unsigned int nbyte,
 		else if (isPwrite)
 			startPos = offset;
 		else
-			startPos = fd->position;
+			startPos = fd->v.position;
 
 		yaffsfs_GetHandle(handle);
 		pos = startPos;
@@ -1286,7 +1374,7 @@ static int yaffsfs_do_write(int handle, const void *vbuf, unsigned int nbyte,
 
 		if (!isPwrite) {
 			if (totalWritten > 0)
-				fd->position = startPos + totalWritten;
+				fd->v.position = startPos + totalWritten;
 			else
 				yaffsfs_SetError(-EINVAL);
 		}
@@ -1307,7 +1395,8 @@ int yaffs_pwrite(int fd, const void *buf, unsigned int nbyte, Y_LOFF_T offset)
 	return yaffsfs_do_write(fd, buf, nbyte, 1, offset);
 }
 
-int yaffs_truncate(const YCHAR *path, Y_LOFF_T new_size)
+int yaffs_truncate_reldir(struct yaffs_obj *reldir, const YCHAR *path,
+				Y_LOFF_T new_size)
 {
 	struct yaffs_obj *obj = NULL;
 	struct yaffs_obj *dir = NULL;
@@ -1327,7 +1416,7 @@ int yaffs_truncate(const YCHAR *path, Y_LOFF_T new_size)
 
 	yaffsfs_Lock();
 
-	obj = yaffsfs_FindObject(NULL, path, 0, 1, &dir, &notDir, &loop);
+	obj = yaffsfs_FindObject(reldir, path, 0, 1, &dir, &notDir, &loop);
 	obj = yaffsfs_FollowLink(obj, 0, &loop);
 
 	if (!dir && notDir)
@@ -1352,6 +1441,17 @@ int yaffs_truncate(const YCHAR *path, Y_LOFF_T new_size)
 	return (result) ? 0 : -1;
 }
 
+int yaffs_truncate_reldev(struct yaffs_dev *dev, const YCHAR *path,
+			Y_LOFF_T new_size)
+{
+	return yaffs_truncate_reldir(ROOT_DIR(dev), path, new_size);
+}
+
+int yaffs_truncate(const YCHAR *path, Y_LOFF_T new_size)
+{
+	return yaffs_truncate_reldir(NULL, path, new_size);
+}
+
 int yaffs_ftruncate(int handle, Y_LOFF_T new_size)
 {
 	struct yaffsfs_FileDes *fd = NULL;
@@ -1400,8 +1500,8 @@ Y_LOFF_T yaffs_lseek(int handle, Y_LOFF_T offset, int whence)
 			if (offset >= 0)
 				pos = offset;
 		} else if (whence == SEEK_CUR) {
-			if ((fd->position + offset) >= 0)
-				pos = (fd->position + offset);
+			if ((fd->v.position + offset) >= 0)
+				pos = (fd->v.position + offset);
 		} else if (whence == SEEK_END) {
 			fSize = yaffs_get_obj_length(obj);
 			if (fSize >= 0 && (fSize + offset) >= 0)
@@ -1409,7 +1509,7 @@ Y_LOFF_T yaffs_lseek(int handle, Y_LOFF_T offset, int whence)
 		}
 
 		if (pos >= 0 && pos <= YAFFS_MAX_FILE_SIZE)
-			fd->position = pos;
+			fd->v.position = pos;
 		else {
 			yaffsfs_SetError(-EINVAL);
 			pos = -1;
@@ -1421,7 +1521,8 @@ Y_LOFF_T yaffs_lseek(int handle, Y_LOFF_T offset, int whence)
 	return pos;
 }
 
-static int yaffsfs_DoUnlink(const YCHAR *path, int isDirectory)
+static int yaffsfs_DoUnlink_reldir(struct yaffs_obj *reldir,
+				const YCHAR *path, int isDirectory)
 {
 	struct yaffs_obj *dir = NULL;
 	struct yaffs_obj *obj = NULL;
@@ -1442,8 +1543,8 @@ static int yaffsfs_DoUnlink(const YCHAR *path, int isDirectory)
 
 	yaffsfs_Lock();
 
-	obj = yaffsfs_FindObject(NULL, path, 0, 0, NULL, NULL, NULL);
-	dir = yaffsfs_FindDirectory(NULL, path, &name, 0, &notDir, &loop);
+	obj = yaffsfs_FindObject(reldir, path, 0, 0, NULL, NULL, NULL);
+	dir = yaffsfs_FindDirectory(reldir, path, &name, 0, &notDir, &loop);
 
 	if (!dir && notDir)
 		yaffsfs_SetError(-ENOTDIR);
@@ -1477,12 +1578,91 @@ static int yaffsfs_DoUnlink(const YCHAR *path, int isDirectory)
 	return (result == YAFFS_FAIL) ? -1 : 0;
 }
 
+int yaffs_unlink_reldir(struct yaffs_obj *reldir, const YCHAR *path)
+{
+	return yaffsfs_DoUnlink_reldir(reldir, path, 0);
+}
+
+int yaffs_unlink_reldev(struct yaffs_dev *dev, const YCHAR *path)
+{
+	return yaffsfs_DoUnlink_reldir(ROOT_DIR(dev), path, 0);
+}
+
 int yaffs_unlink(const YCHAR *path)
 {
-	return yaffsfs_DoUnlink(path, 0);
+	return yaffs_unlink_reldir(NULL, path);
 }
 
-int yaffs_rename(const YCHAR *oldPath, const YCHAR *newPath)
+int yaffs_funlink(int fd)
+{
+	struct yaffs_obj *obj;
+	int retVal = -1;
+
+	yaffsfs_Lock();
+	obj = yaffsfs_HandleToObject(fd);
+
+	if (!obj)
+		yaffsfs_SetError(-EBADF);
+	else if (obj->my_dev->read_only)
+		yaffsfs_SetError(-EROFS);
+	else if (obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY &&
+			!(list_empty(&obj->variant.dir_variant.children)))
+		yaffsfs_SetError(-ENOTEMPTY);
+	else if (obj == obj->my_dev->root_dir)
+		yaffsfs_SetError(-EBUSY);	/* Can't rmdir a root */
+	else if (yaffs_unlink_obj(obj) == YAFFS_OK)
+			retVal = 0;
+
+	yaffsfs_Unlock();
+
+	return retVal;
+}
+
+int yaffs_fgetfl(int fd, int *flags)
+{
+	struct yaffsfs_FileDes *fdp = yaffsfs_HandleToFileDes(fd);
+	int retVal;
+	
+	yaffsfs_Lock();
+
+	if(!flags || !fdp) {
+		yaffsfs_SetError(-EINVAL);
+		retVal = -1;
+	} else {
+		if (fdp->reading && fdp->writing)
+			*flags = O_RDWR;
+		else if (fdp->writing)
+			*flags = O_WRONLY;
+		else
+			*flags = O_RDONLY;
+		retVal = 0;
+	}
+	
+	yaffsfs_Unlock();
+	return retVal;
+}
+
+
+static int rename_file_over_dir(struct yaffs_obj *obj, struct yaffs_obj *newobj)
+{
+	if (obj && obj->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY &&
+	    newobj && newobj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY)
+		return 1;
+	else
+		return 0;
+}
+
+static int rename_dir_over_file(struct yaffs_obj *obj, struct yaffs_obj *newobj)
+{
+	if (obj && obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY &&
+	    newobj && newobj->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY)
+		return 1;
+	else
+		return 0;
+}
+
+int yaffs_rename_reldir(struct yaffs_obj *reldir,
+			const YCHAR *oldPath, const YCHAR *newPath)
 {
 	struct yaffs_obj *olddir = NULL;
 	struct yaffs_obj *newdir = NULL;
@@ -1519,12 +1699,12 @@ int yaffs_rename(const YCHAR *oldPath, const YCHAR *newPath)
 
 	yaffsfs_Lock();
 
-	olddir = yaffsfs_FindDirectory(NULL, oldPath, &oldname, 0,
+	olddir = yaffsfs_FindDirectory(reldir, oldPath, &oldname, 0,
 				       &notOldDir, &oldLoop);
-	newdir = yaffsfs_FindDirectory(NULL, newPath, &newname, 0,
+	newdir = yaffsfs_FindDirectory(reldir, 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);
+	obj = yaffsfs_FindObject(reldir, oldPath, 0, 0, NULL, NULL, NULL);
+	newobj = yaffsfs_FindObject(reldir, newPath, 0, 0, NULL, NULL, NULL);
 
 	/* If the object being renamed is a directory and the
 	 * path ended with a "/" then the olddir == obj.
@@ -1551,6 +1731,12 @@ int yaffs_rename(const YCHAR *oldPath, const YCHAR *newPath)
 	} else if (obj->my_dev->read_only) {
 		yaffsfs_SetError(-EROFS);
 		rename_allowed = 0;
+	} else if (rename_file_over_dir(obj, newobj)) {
+		yaffsfs_SetError(-EISDIR);
+		rename_allowed = 0;
+	} else if (rename_dir_over_file(obj, newobj)) {
+		yaffsfs_SetError(-ENOTDIR);
+		rename_allowed = 0;
 	} else if (yaffs_is_non_empty_dir(newobj)) {
 		yaffsfs_SetError(-ENOTEMPTY);
 		rename_allowed = 0;
@@ -1587,6 +1773,16 @@ int yaffs_rename(const YCHAR *oldPath, const YCHAR *newPath)
 	return (result == YAFFS_FAIL) ? -1 : 0;
 }
 
+int yaffs_rename_reldev(struct yaffs_dev *dev, const YCHAR *oldPath,
+			const YCHAR *newPath)
+{
+	return yaffs_rename_reldir(ROOT_DIR(dev), oldPath, newPath);
+}
+int yaffs_rename(const YCHAR *oldPath, const YCHAR *newPath)
+{
+	return yaffs_rename_reldir(NULL, oldPath, newPath);
+}
+
 static int yaffsfs_DoStat(struct yaffs_obj *obj, struct yaffs_stat *buf)
 {
 	int retVal = -1;
@@ -1630,7 +1826,7 @@ static int yaffsfs_DoStat(struct yaffs_obj *obj, struct yaffs_stat *buf)
 	return retVal;
 }
 
-static int yaffsfs_DoStatOrLStat(const YCHAR *path,
+static int yaffsfs_DoStatOrLStat_reldir(struct yaffs_obj *reldir, const YCHAR *path,
 				 struct yaffs_stat *buf, int doLStat)
 {
 	struct yaffs_obj *obj = NULL;
@@ -1652,7 +1848,7 @@ static int yaffsfs_DoStatOrLStat(const YCHAR *path,
 
 	yaffsfs_Lock();
 
-	obj = yaffsfs_FindObject(NULL, path, 0, 1, &dir, &notDir, &loop);
+	obj = yaffsfs_FindObject(reldir, path, 0, 1, &dir, &notDir, &loop);
 
 	if (!doLStat && obj)
 		obj = yaffsfs_FollowLink(obj, 0, &loop);
@@ -1672,14 +1868,38 @@ static int yaffsfs_DoStatOrLStat(const YCHAR *path,
 
 }
 
+int yaffs_stat_reldir(struct yaffs_obj *reldir, const YCHAR *path,
+		    struct yaffs_stat *buf)
+{
+	return yaffsfs_DoStatOrLStat_reldir(reldir, path, buf, 0);
+}
+
+int yaffs_lstat_reldir(struct yaffs_obj *reldir, const YCHAR *path,
+		    struct yaffs_stat *buf)
+{
+	return yaffsfs_DoStatOrLStat_reldir(reldir, path, buf, 1);
+}
+
+int yaffs_stat_reldev(struct yaffs_dev *dev, const YCHAR *path,
+		    struct yaffs_stat *buf)
+{
+	return yaffsfs_DoStatOrLStat_reldir(ROOT_DIR(dev), path, buf, 0);
+}
+
+int yaffs_lstat_reldev(struct yaffs_dev *dev, const YCHAR *path,
+		    struct yaffs_stat *buf)
+{
+	return yaffsfs_DoStatOrLStat_reldir(ROOT_DIR(dev), path, buf, 1);
+}
+
 int yaffs_stat(const YCHAR *path, struct yaffs_stat *buf)
 {
-	return yaffsfs_DoStatOrLStat(path, buf, 0);
+	return yaffs_stat_reldir(NULL, path, buf);
 }
 
 int yaffs_lstat(const YCHAR *path, struct yaffs_stat *buf)
 {
-	return yaffsfs_DoStatOrLStat(path, buf, 1);
+	return yaffs_lstat_reldir(NULL, path, buf);
 }
 
 int yaffs_fstat(int fd, struct yaffs_stat *buf)
@@ -1711,8 +1931,6 @@ 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);
@@ -1722,6 +1940,7 @@ static int yaffsfs_DoUtime(struct yaffs_obj *obj,
 		return -1;
 	}
 
+#if !CONFIG_YAFFS_WINCE
 	if (!buf) {
 		local.actime = Y_CURRENT_TIME;
 		local.modtime = local.actime;
@@ -1729,17 +1948,21 @@ static int yaffsfs_DoUtime(struct yaffs_obj *obj,
 	}
 
 	if (obj) {
+		int result;
+
 		obj->yst_atime = buf->actime;
 		obj->yst_mtime = buf->modtime;
 		obj->dirty = 1;
-		result = yaffs_flush_file(obj, 0, 0);
+		result = yaffs_flush_file(obj, 0, 0, 0);
 		retVal = result == YAFFS_OK ? 0 : -1;
 	}
+#endif
 
 	return retVal;
 }
 
-int yaffs_utime(const YCHAR *path, const struct yaffs_utimbuf *buf)
+int yaffs_utime_reldir(struct yaffs_obj *reldir, const YCHAR *path,
+		     const struct yaffs_utimbuf *buf)
 {
 	struct yaffs_obj *obj = NULL;
 	struct yaffs_obj *dir = NULL;
@@ -1759,7 +1982,7 @@ int yaffs_utime(const YCHAR *path, const struct yaffs_utimbuf *buf)
 
 	yaffsfs_Lock();
 
-	obj = yaffsfs_FindObject(NULL, path, 0, 1, &dir, &notDir, &loop);
+	obj = yaffsfs_FindObject(reldir, path, 0, 1, &dir, &notDir, &loop);
 
 	if (!dir && notDir)
 		yaffsfs_SetError(-ENOTDIR);
@@ -1776,6 +1999,17 @@ int yaffs_utime(const YCHAR *path, const struct yaffs_utimbuf *buf)
 
 }
 
+int yaffs_utime_reldev(struct yaffs_dev *dev, const YCHAR *path,
+			const struct yaffs_utimbuf *buf)
+{
+	return yaffs_utime_reldir(ROOT_DIR(dev), path, buf);
+}
+
+int yaffs_utime(const YCHAR *path, const struct yaffs_utimbuf *buf)
+{
+	return yaffs_utime_reldir(NULL, path, buf);
+}
+
 int yaffs_futime(int fd, const struct yaffs_utimbuf *buf)
 {
 	struct yaffs_obj *obj;
@@ -1799,8 +2033,9 @@ int yaffs_futime(int fd, const struct yaffs_utimbuf *buf)
 #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_reldir(struct yaffs_obj *reldir, const YCHAR *path,
+				  const char *name, const void *data, int size,
+				  int flags, int follow)
 {
 	struct yaffs_obj *obj;
 	struct yaffs_obj *dir;
@@ -1823,7 +2058,7 @@ static int yaffs_do_setxattr(const YCHAR *path, const char *name,
 
 	yaffsfs_Lock();
 
-	obj = yaffsfs_FindObject(NULL, path, 0, 1, &dir, &notDir, &loop);
+	obj = yaffsfs_FindObject(reldir, path, 0, 1, &dir, &notDir, &loop);
 
 	if (follow)
 		obj = yaffsfs_FollowLink(obj, 0, &loop);
@@ -1848,16 +2083,40 @@ static int yaffs_do_setxattr(const YCHAR *path, const char *name,
 
 }
 
+int yaffs_setxattr_reldir(struct yaffs_obj *reldir, const YCHAR *path,
+			const char *name, const void *data, int size, int flags)
+{
+	return yaffs_do_setxattr_reldir(reldir, path, name, data, size, flags, 1);
+}
+
+int yaffs_setxattr_reldev(struct yaffs_dev *dev, const YCHAR *path,
+		const char *name, const void *data, int size, int flags)
+{
+	return yaffs_setxattr_reldir(ROOT_DIR(dev), path, name, data, size, flags);
+}
+
 int yaffs_setxattr(const YCHAR *path, const char *name,
 		   const void *data, int size, int flags)
 {
-	return yaffs_do_setxattr(path, name, data, size, flags, 1);
+	return yaffs_setxattr_reldir(NULL, path, name, data, size, flags);
 }
 
-int yaffs_lsetxattr(const YCHAR *path, const char *name,
+int yaffs_lsetxattr_reldir(struct yaffs_obj *reldir, const YCHAR *path, const char *name,
 		    const void *data, int size, int flags)
 {
-	return yaffs_do_setxattr(path, name, data, size, flags, 0);
+	return yaffs_do_setxattr_reldir(reldir, path, name, data, size, flags, 0);
+}
+
+int yaffs_lsetxattr_reldev(struct yaffs_dev *dev, const YCHAR *path, const char *name,
+		   const void *data, int size, int flags)
+{
+	return yaffs_lsetxattr_reldir(ROOT_DIR(dev), path, name, data, size, flags);
+}
+
+int yaffs_lsetxattr(const YCHAR *path, const char *name,
+		   const void *data, int size, int flags)
+{
+	return yaffs_lsetxattr_reldir(NULL, path, name, data, size, flags);
 }
 
 int yaffs_fsetxattr(int fd, const char *name,
@@ -1891,8 +2150,8 @@ int yaffs_fsetxattr(int fd, const char *name,
 	return retVal;
 }
 
-static int yaffs_do_getxattr(const YCHAR *path, const char *name,
-			     void *data, int size, int follow)
+static int yaffs_do_getxattr_reldir(struct yaffs_obj *reldir, const YCHAR *path,
+			const char *name, void *data, int size, int follow)
 {
 	struct yaffs_obj *obj;
 	struct yaffs_obj *dir;
@@ -1914,7 +2173,7 @@ static int yaffs_do_getxattr(const YCHAR *path, const char *name,
 
 	yaffsfs_Lock();
 
-	obj = yaffsfs_FindObject(NULL, path, 0, 1, &dir, &notDir, &loop);
+	obj = yaffsfs_FindObject(reldir, path, 0, 1, &dir, &notDir, &loop);
 
 	if (follow)
 		obj = yaffsfs_FollowLink(obj, 0, &loop);
@@ -1938,14 +2197,36 @@ static int yaffs_do_getxattr(const YCHAR *path, const char *name,
 
 }
 
+int yaffs_getxattr_reldir(struct yaffs_obj *reldir, const YCHAR *path,
+			const char *name, void *data, int size)
+{
+	return yaffs_do_getxattr_reldir(reldir, path, name, data, size, 1);
+}
+
+int yaffs_getxattr_reldev(struct yaffs_dev *dev, const YCHAR *path, const char *name, void *data, int size)
+{
+	return yaffs_getxattr_reldir(ROOT_DIR(dev), path, name, data, size);
+}
+
 int yaffs_getxattr(const YCHAR *path, const char *name, void *data, int size)
 {
-	return yaffs_do_getxattr(path, name, data, size, 1);
+	return yaffs_getxattr_reldir(NULL, path, name, data, size);
+}
+
+int yaffs_lgetxattr_reldir(struct yaffs_obj *reldir, const YCHAR *path,
+			const char *name, void *data, int size)
+{
+	return yaffs_do_getxattr_reldir(reldir, path, name, data, size, 0);
+}
+
+int yaffs_lgetxattr_reldev(struct yaffs_dev *dev, const YCHAR *path, const char *name, void *data, int size)
+{
+	return yaffs_lgetxattr_reldir(ROOT_DIR(dev), path, name, data, size);
 }
 
 int yaffs_lgetxattr(const YCHAR *path, const char *name, void *data, int size)
 {
-	return yaffs_do_getxattr(path, name, data, size, 0);
+	return yaffs_lgetxattr_reldir(NULL, path, name, data, size);
 }
 
 int yaffs_fgetxattr(int fd, const char *name, void *data, int size)
@@ -1978,8 +2259,8 @@ int yaffs_fgetxattr(int fd, const char *name, void *data, int size)
 	return retVal;
 }
 
-static int yaffs_do_listxattr(const YCHAR *path, char *data,
-			      int size, int follow)
+static int yaffs_do_listxattr_reldir(struct yaffs_obj *reldir, const YCHAR *path,
+				char *data, int size, int follow)
 {
 	struct yaffs_obj *obj = NULL;
 	struct yaffs_obj *dir = NULL;
@@ -2000,7 +2281,7 @@ static int yaffs_do_listxattr(const YCHAR *path, char *data,
 
 	yaffsfs_Lock();
 
-	obj = yaffsfs_FindObject(NULL, path, 0, 1, &dir, &notDir, &loop);
+	obj = yaffsfs_FindObject(reldir, path, 0, 1, &dir, &notDir, &loop);
 
 	if (follow)
 		obj = yaffsfs_FollowLink(obj, 0, &loop);
@@ -2025,14 +2306,36 @@ static int yaffs_do_listxattr(const YCHAR *path, char *data,
 
 }
 
+int yaffs_listxattr_reldir(struct yaffs_obj *reldir, const YCHAR *path,
+			char *data, int size)
+{
+	return yaffs_do_listxattr_reldir(reldir, path, data, size, 1);
+}
+
+int yaffs_listxattr_reldev(struct yaffs_dev *dev, const YCHAR *path, char *data, int size)
+{
+	return yaffs_listxattr_reldir(ROOT_DIR(dev), path, data, size);
+}
+
 int yaffs_listxattr(const YCHAR *path, char *data, int size)
 {
-	return yaffs_do_listxattr(path, data, size, 1);
+	return yaffs_listxattr_reldir(NULL, path, data, size);
+}
+
+int yaffs_llistxattr_reldir(struct yaffs_obj *reldir, const YCHAR *path,
+			char *data, int size)
+{
+	return yaffs_do_listxattr_reldir(reldir, path, data, size, 0);
+}
+
+int yaffs_llistxattr_reldev(struct yaffs_dev *dev, const YCHAR *path, char *data, int size)
+{
+	return yaffs_llistxattr_reldir(ROOT_DIR(dev), path, data, size);
 }
 
 int yaffs_llistxattr(const YCHAR *path, char *data, int size)
 {
-	return yaffs_do_listxattr(path, data, size, 0);
+	return yaffs_llistxattr_reldir(NULL, path, data, size);
 }
 
 int yaffs_flistxattr(int fd, char *data, int size)
@@ -2064,8 +2367,8 @@ int yaffs_flistxattr(int fd, char *data, int size)
 	return retVal;
 }
 
-static int yaffs_do_removexattr(const YCHAR *path, const char *name,
-				int follow)
+static int yaffs_do_removexattr_reldir(struct yaffs_obj *reldir, const YCHAR *path,
+				const char *name, int follow)
 {
 	struct yaffs_obj *obj = NULL;
 	struct yaffs_obj *dir = NULL;
@@ -2086,7 +2389,7 @@ static int yaffs_do_removexattr(const YCHAR *path, const char *name,
 
 	yaffsfs_Lock();
 
-	obj = yaffsfs_FindObject(NULL, path, 0, 1, &dir, &notDir, &loop);
+	obj = yaffsfs_FindObject(reldir, path, 0, 1, &dir, &notDir, &loop);
 
 	if (follow)
 		obj = yaffsfs_FollowLink(obj, 0, &loop);
@@ -2111,14 +2414,36 @@ static int yaffs_do_removexattr(const YCHAR *path, const char *name,
 
 }
 
+int yaffs_removexattr_reldir(struct yaffs_obj *reldir, const YCHAR *path,
+			const char *name)
+{
+	return yaffs_do_removexattr_reldir(reldir, path, name, 1);
+}
+
+int yaffs_removexattr_reldev(struct yaffs_dev *dev, const YCHAR *path, const char *name)
+{
+	return yaffs_removexattr_reldir(ROOT_DIR(dev), path, name);
+}
+
 int yaffs_removexattr(const YCHAR *path, const char *name)
 {
-	return yaffs_do_removexattr(path, name, 1);
+	return yaffs_removexattr_reldir(NULL, path, name);
+}
+
+int yaffs_lremovexattr_reldir(struct yaffs_obj *reldir, const YCHAR *path,
+			const char *name)
+{
+	return yaffs_do_removexattr_reldir(reldir, path, name, 0);
+}
+
+int yaffs_lremovexattr_reldev(struct yaffs_dev *dev, const YCHAR *path, const char *name)
+{
+	return yaffs_lremovexattr_reldir(ROOT_DIR(dev), path, name);
 }
 
 int yaffs_lremovexattr(const YCHAR *path, const char *name)
 {
-	return yaffs_do_removexattr(path, name, 0);
+	return yaffs_lremovexattr_reldir(NULL, path, name);
 }
 
 int yaffs_fremovexattr(int fd, const char *name)
@@ -2214,7 +2539,7 @@ int yaffs_set_wince_times(int fd,
 		}
 
 		obj->dirty = 1;
-		result = yaffs_flush_file(obj, 0, 0);
+		result = yaffs_flush_file(obj, 0, 0, 0);
 		retVal = 0;
 	} else
 		/* bad handle */
@@ -2237,13 +2562,13 @@ static int yaffsfs_DoChMod(struct yaffs_obj *obj, mode_t mode)
 	if (obj) {
 		obj->yst_mode = mode;
 		obj->dirty = 1;
-		result = yaffs_flush_file(obj, 0, 0);
+		result = yaffs_flush_file(obj, 0, 0, 0);
 	}
 
 	return result == YAFFS_OK ? 0 : -1;
 }
 
-int yaffs_access(const YCHAR *path, int amode)
+int yaffs_access_reldir(struct yaffs_obj *reldir, const YCHAR *path, int amode)
 {
 	struct yaffs_obj *obj = NULL;
 	struct yaffs_obj *dir = NULL;
@@ -2268,7 +2593,7 @@ int yaffs_access(const YCHAR *path, int amode)
 
 	yaffsfs_Lock();
 
-	obj = yaffsfs_FindObject(NULL, path, 0, 1, &dir, &notDir, &loop);
+	obj = yaffsfs_FindObject(reldir, path, 0, 1, &dir, &notDir, &loop);
 	obj = yaffsfs_FollowLink(obj, 0, &loop);
 
 	if (!dir && notDir)
@@ -2282,11 +2607,11 @@ int yaffs_access(const YCHAR *path, int amode)
 	else {
 		int access_ok = 1;
 
-		if ((amode & R_OK) && !(obj->yst_mode & S_IREAD))
+		if ((amode & R_OK) && !(obj->yst_mode & S_IRUSR))
 			access_ok = 0;
-		if ((amode & W_OK) && !(obj->yst_mode & S_IWRITE))
+		if ((amode & W_OK) && !(obj->yst_mode & S_IWUSR))
 			access_ok = 0;
-		if ((amode & X_OK) && !(obj->yst_mode & S_IEXEC))
+		if ((amode & X_OK) && !(obj->yst_mode & S_IXUSR))
 			access_ok = 0;
 
 		if (!access_ok)
@@ -2301,7 +2626,17 @@ int yaffs_access(const YCHAR *path, int amode)
 
 }
 
-int yaffs_chmod(const YCHAR *path, mode_t mode)
+int yaffs_access_reldev(struct yaffs_dev *dev, const YCHAR *path, int amode)
+{
+	return yaffs_access_reldir(ROOT_DIR(dev), path, amode);
+}
+
+int yaffs_access(const YCHAR *path, int amode)
+{
+	return yaffs_access_reldir(NULL, path, amode);
+}
+
+int yaffs_chmod_reldir(struct yaffs_obj *reldir, const YCHAR *path, mode_t mode)
 {
 	struct yaffs_obj *obj = NULL;
 	struct yaffs_obj *dir = NULL;
@@ -2326,7 +2661,7 @@ int yaffs_chmod(const YCHAR *path, mode_t mode)
 
 	yaffsfs_Lock();
 
-	obj = yaffsfs_FindObject(NULL, path, 0, 1, &dir, &notDir, &loop);
+	obj = yaffsfs_FindObject(reldir, path, 0, 1, &dir, &notDir, &loop);
 	obj = yaffsfs_FollowLink(obj, 0, &loop);
 
 	if (!dir && notDir)
@@ -2346,6 +2681,16 @@ int yaffs_chmod(const YCHAR *path, mode_t mode)
 
 }
 
+int yaffs_chmod_reldev(struct yaffs_dev *dev, const YCHAR *path, mode_t mode)
+{
+	return yaffs_chmod_reldir(ROOT_DIR(dev), path, mode);
+}
+
+int yaffs_chmod(const YCHAR *path, mode_t mode)
+{
+	return yaffs_chmod_reldir(NULL, path, mode);
+}
+
 int yaffs_fchmod(int fd, mode_t mode)
 {
 	struct yaffs_obj *obj;
@@ -2371,7 +2716,7 @@ int yaffs_fchmod(int fd, mode_t mode)
 	return retVal;
 }
 
-int yaffs_mkdir(const YCHAR *path, mode_t mode)
+int yaffs_mkdir_reldir(struct yaffs_obj *reldir, const YCHAR *path, mode_t mode)
 {
 	struct yaffs_obj *parent = NULL;
 	struct yaffs_obj *dir = NULL;
@@ -2399,7 +2744,7 @@ int yaffs_mkdir(const YCHAR *path, mode_t mode)
 		path = alt_path;
 
 	yaffsfs_Lock();
-	parent = yaffsfs_FindDirectory(NULL, path, &name, 0, &notDir, &loop);
+	parent = yaffsfs_FindDirectory(reldir, path, &name, 0, &notDir, &loop);
 	if (!parent && notDir)
 		yaffsfs_SetError(-ENOTDIR);
 	else if (loop)
@@ -2430,7 +2775,17 @@ int yaffs_mkdir(const YCHAR *path, mode_t mode)
 	return retVal;
 }
 
-int yaffs_rmdir(const YCHAR *path)
+int yaffs_mkdir_reldev(struct yaffs_dev *dev, const YCHAR *path, mode_t mode)
+{
+	return yaffs_mkdir_reldir(ROOT_DIR(dev), path, mode);
+}
+
+int yaffs_mkdir(const YCHAR *path, mode_t mode)
+{
+	return yaffs_mkdir_reldir(NULL, path, mode);
+}
+
+int yaffs_rmdir_reldir(struct yaffs_obj *reldir, const YCHAR *path)
 {
 	int result;
 	YCHAR *alt_path;
@@ -2451,13 +2806,26 @@ int yaffs_rmdir(const YCHAR *path)
 	}
 	if (alt_path)
 		path = alt_path;
-	result = yaffsfs_DoUnlink(path, 1);
+	result = yaffsfs_DoUnlink_reldir(reldir, path, 1);
 
 	kfree(alt_path);
 
 	return result;
 }
 
+int yaffs_rmdir_reldev(struct yaffs_dev *dev, const YCHAR *path)
+{
+	return yaffs_rmdir_reldir(ROOT_DIR(dev), path);
+}
+
+int yaffs_rmdir(const YCHAR *path)
+{
+	return yaffs_rmdir_reldir(NULL, path);
+}
+
+/*
+ * The mount/unmount/sync functions act on devices rather than reldirs.
+ */
 void *yaffs_getdev(const YCHAR *path)
 {
 	struct yaffs_dev *dev = NULL;
@@ -2466,29 +2834,33 @@ void *yaffs_getdev(const YCHAR *path)
 	return (void *)dev;
 }
 
-int yaffs_mount_common(const YCHAR *path, int read_only, int skip_checkpt)
+int yaffs_mount_common(struct yaffs_dev *dev, const YCHAR *path,
+				int read_only, int skip_checkpt)
 {
 	int retVal = -1;
 	int result = YAFFS_FAIL;
-	struct yaffs_dev *dev = NULL;
 
-	if (yaffsfs_CheckMemRegion(path, 0, 0) < 0) {
-		yaffsfs_SetError(-EFAULT);
-		return -1;
-	}
+	if (!dev) {
+		if (yaffsfs_CheckMemRegion(path, 0, 0) < 0) {
+			yaffsfs_SetError(-EFAULT);
+			return -1;
+		}
 
-	yaffs_trace(YAFFS_TRACE_MOUNT, "yaffs: Mounting %s", path);
+		yaffs_trace(YAFFS_TRACE_MOUNT, "yaffs: Mounting %s", path);
 
-	if (yaffsfs_CheckPath(path) < 0) {
-		yaffsfs_SetError(-ENAMETOOLONG);
-		return -1;
+		if (yaffsfs_CheckPath(path) < 0) {
+			yaffsfs_SetError(-ENAMETOOLONG);
+			return -1;
+		}
 	}
 
 	yaffsfs_Lock();
 
 	yaffsfs_InitHandles();
 
-	dev = yaffsfs_FindMountPoint(path);
+	if (!dev)
+		dev = yaffsfs_FindMountPoint(path);
+
 	if (dev) {
 		if (!dev->is_mounted) {
 			dev->read_only = read_only ? 1 : 0;
@@ -2515,34 +2887,59 @@ int yaffs_mount_common(const YCHAR *path, int read_only, int skip_checkpt)
 
 }
 
+int yaffs_mount3_reldev(struct yaffs_dev *dev, int read_only, int skip_checkpt)
+{
+	return yaffs_mount_common(dev, NULL, read_only, skip_checkpt);
+}
+
+int yaffs_mount3(const YCHAR *path, int read_only, int skip_checkpt)
+{
+	return yaffs_mount_common(NULL, path, read_only, skip_checkpt);
+}
+
+int yaffs_mount2_reldev(struct yaffs_dev *dev, int readonly)
+{
+	return yaffs_mount_common(dev, NULL, readonly, 0);
+}
+
 int yaffs_mount2(const YCHAR *path, int readonly)
 {
-	return yaffs_mount_common(path, readonly, 0);
+	return yaffs_mount_common(NULL, path, readonly, 0);
+}
+
+int yaffs_mount_reldev(struct yaffs_dev *dev)
+{
+	return yaffs_mount_common(dev, NULL, 0, 0);
 }
 
 int yaffs_mount(const YCHAR *path)
 {
-	return yaffs_mount_common(path, 0, 0);
+	return yaffs_mount_common(NULL, path, 0, 0);
 }
 
-int yaffs_sync(const YCHAR *path)
+static int yaffs_sync_common(struct yaffs_dev *dev,
+			     const YCHAR *path,
+			     int do_checkpt)
 {
 	int retVal = -1;
-	struct yaffs_dev *dev = NULL;
 	YCHAR *dummy;
 
-	if (yaffsfs_CheckMemRegion(path, 0, 0) < 0) {
-		yaffsfs_SetError(-EFAULT);
-		return -1;
-	}
+	if (!dev) {
+		if (yaffsfs_CheckMemRegion(path, 0, 0) < 0) {
+			yaffsfs_SetError(-EFAULT);
+			return -1;
+		}
 
-	if (yaffsfs_CheckPath(path) < 0) {
-		yaffsfs_SetError(-ENAMETOOLONG);
-		return -1;
+		if (yaffsfs_CheckPath(path) < 0) {
+			yaffsfs_SetError(-ENAMETOOLONG);
+			return -1;
+		}
 	}
 
 	yaffsfs_Lock();
-	dev = yaffsfs_FindDevice(path, &dummy);
+	if (!dev)
+		dev = yaffsfs_FindDevice(path, &dummy);
+
 	if (dev) {
 		if (!dev->is_mounted)
 			yaffsfs_SetError(-EINVAL);
@@ -2550,8 +2947,9 @@ int yaffs_sync(const YCHAR *path)
 			yaffsfs_SetError(-EROFS);
 		else {
 
-			yaffs_flush_whole_cache(dev);
-			yaffs_checkpoint_save(dev);
+			yaffs_flush_whole_cache(dev, 0);
+			if (do_checkpt)
+				yaffs_checkpoint_save(dev);
 			retVal = 0;
 
 		}
@@ -2562,6 +2960,77 @@ int yaffs_sync(const YCHAR *path)
 	return retVal;
 }
 
+int yaffs_sync_files_reldev(struct yaffs_dev *dev)
+{
+	return yaffs_sync_common(dev, NULL, 0);
+}
+
+int yaffs_sync_files(const YCHAR *path)
+{
+	return yaffs_sync_common(NULL, path, 0);
+}
+
+int yaffs_sync_reldev(struct yaffs_dev *dev)
+{
+	return yaffs_sync_common(dev, NULL, 1);
+}
+
+int yaffs_sync(const YCHAR *path)
+{
+	return yaffs_sync_common(NULL, path, 1);
+}
+
+
+static int yaffsfs_bg_gc_common(struct yaffs_dev *dev,
+				const YCHAR *path,
+				int urgency)
+{
+	int retVal = -1;
+	YCHAR *dummy;
+
+	if (!dev) {
+		if (yaffsfs_CheckMemRegion(path, 0, 0) < 0) {
+			yaffsfs_SetError(-EFAULT);
+			return -1;
+		}
+
+		if (yaffsfs_CheckPath(path) < 0) {
+			yaffsfs_SetError(-ENAMETOOLONG);
+			return -1;
+		}
+	}
+
+	yaffsfs_Lock();
+	if (!dev)
+		dev = yaffsfs_FindDevice(path, &dummy);
+
+	if (dev) {
+		if (!dev->is_mounted)
+			yaffsfs_SetError(-EINVAL);
+		else
+			retVal = yaffs_bg_gc(dev, urgency);
+	} else
+		yaffsfs_SetError(-ENODEV);
+
+	yaffsfs_Unlock();
+	return retVal;
+}
+
+/* Background gc functions.
+ * These return 0 when bg done or greater than 0 when gc has been
+ * done and there is still a lot of garbage to be cleaned up.
+ */
+
+int yaffs_do_background_gc(const YCHAR *path, int urgency)
+{
+	return yaffsfs_bg_gc_common(NULL, path, urgency);
+}
+
+int yaffs_do_background_gc_reldev(struct yaffs_dev *dev, int urgency)
+{
+	return yaffsfs_bg_gc_common(dev, NULL, urgency);
+}
+
 static int yaffsfs_IsDevBusy(struct yaffs_dev *dev)
 {
 	int i;
@@ -2575,10 +3044,10 @@ static int yaffsfs_IsDevBusy(struct yaffs_dev *dev)
 	return 0;
 }
 
-int yaffs_remount(const YCHAR *path, int force, int read_only)
+int yaffs_remount_common(struct yaffs_dev *dev, const YCHAR *path,
+		       int force, int read_only)
 {
 	int retVal = -1;
-	struct yaffs_dev *dev = NULL;
 
 	if (yaffsfs_CheckMemRegion(path, 0, 0) < 0) {
 		yaffsfs_SetError(-EFAULT);
@@ -2591,10 +3060,12 @@ int yaffs_remount(const YCHAR *path, int force, int read_only)
 	}
 
 	yaffsfs_Lock();
-	dev = yaffsfs_FindMountPoint(path);
+	if (!dev)
+		dev = yaffsfs_FindMountPoint(path);
+
 	if (dev) {
 		if (dev->is_mounted) {
-			yaffs_flush_whole_cache(dev);
+			yaffs_flush_whole_cache(dev, 0);
 
 			if (force || !yaffsfs_IsDevBusy(dev)) {
 				if (read_only)
@@ -2615,10 +3086,18 @@ int yaffs_remount(const YCHAR *path, int force, int read_only)
 
 }
 
-int yaffs_unmount2(const YCHAR *path, int force)
+int yaffs_remount_reldev(struct yaffs_dev *dev, int force, int read_only)
+{
+	return yaffs_remount_common(dev, NULL, force, read_only);
+}
+int yaffs_remount(const YCHAR *path, int force, int read_only)
+{
+	return yaffs_remount_common(NULL, path, force, read_only);
+}
+
+int yaffs_unmount2_common(struct yaffs_dev *dev, const YCHAR *path, int force)
 {
 	int retVal = -1;
-	struct yaffs_dev *dev = NULL;
 
 	if (yaffsfs_CheckMemRegion(path, 0, 0) < 0) {
 		yaffsfs_SetError(-EFAULT);
@@ -2631,11 +3110,13 @@ int yaffs_unmount2(const YCHAR *path, int force)
 	}
 
 	yaffsfs_Lock();
-	dev = yaffsfs_FindMountPoint(path);
+	if (!dev)
+		dev = yaffsfs_FindMountPoint(path);
+
 	if (dev) {
 		if (dev->is_mounted) {
 			int inUse;
-			yaffs_flush_whole_cache(dev);
+			yaffs_flush_whole_cache(dev, 0);
 			yaffs_checkpoint_save(dev);
 			inUse = yaffsfs_IsDevBusy(dev);
 			if (!inUse || force) {
@@ -2658,39 +3139,57 @@ int yaffs_unmount2(const YCHAR *path, int force)
 
 }
 
+int yaffs_unmount2_reldev(struct yaffs_dev *dev, int force)
+{
+	return yaffs_unmount2_common(dev, NULL, force);
+}
+
+int yaffs_unmount2(const YCHAR *path, int force)
+{
+	return yaffs_unmount2_common(NULL, path, force);
+}
+
+int yaffs_unmount_reldev(struct yaffs_dev *dev)
+{
+	return yaffs_unmount2_reldev(dev, 0);
+}
+
 int yaffs_unmount(const YCHAR *path)
 {
 	return yaffs_unmount2(path, 0);
 }
 
-int yaffs_format(const YCHAR *path,
+int yaffs_format_common(struct yaffs_dev *dev,
+		const YCHAR *path,
 		int unmount_flag,
 		int force_unmount_flag,
 		int remount_flag)
 {
 	int retVal = 0;
-	struct yaffs_dev *dev = NULL;
 	int result;
 
-	if (!path) {
-		yaffsfs_SetError(-EFAULT);
-		return -1;
-	}
+	if (!dev) {
+		if (!path) {
+			yaffsfs_SetError(-EFAULT);
+			return -1;
+		}
 
-	if (yaffsfs_CheckPath(path) < 0) {
-		yaffsfs_SetError(-ENAMETOOLONG);
-		return -1;
+		if (yaffsfs_CheckPath(path) < 0) {
+			yaffsfs_SetError(-ENAMETOOLONG);
+			return -1;
+		}
 	}
 
 	yaffsfs_Lock();
-	dev = yaffsfs_FindMountPoint(path);
+	if (!dev)
+		dev = yaffsfs_FindMountPoint(path);
 
 	if (dev) {
 		int was_mounted = dev->is_mounted;
 
 		if (dev->is_mounted && unmount_flag) {
 			int inUse;
-			yaffs_flush_whole_cache(dev);
+			yaffs_flush_whole_cache(dev, 0);
 			yaffs_checkpoint_save(dev);
 			inUse = yaffsfs_IsDevBusy(dev);
 			if (!inUse || force_unmount_flag) {
@@ -2704,7 +3203,7 @@ int yaffs_format(const YCHAR *path,
 				yaffsfs_SetError(-EBUSY);
 				retVal = -1;
 		} else {
-			yaffs_format_dev(dev);
+			yaffs_guts_format_dev(dev);
 			if(was_mounted && remount_flag) {
 				result = yaffs_guts_initialise(dev);
 				if (result == YAFFS_FAIL) {
@@ -2723,25 +3222,44 @@ int yaffs_format(const YCHAR *path,
 
 }
 
+int yaffs_format_reldev(struct yaffs_dev *dev,
+		int unmount_flag,
+		int force_unmount_flag,
+		int remount_flag)
+{
+	return yaffs_format_common(dev, NULL, unmount_flag,
+			force_unmount_flag, remount_flag);
+}
+
+int yaffs_format(const YCHAR *path,
+		int unmount_flag,
+		int force_unmount_flag,
+		int remount_flag)
+{
+	return yaffs_format_common(NULL, path, unmount_flag,
+			force_unmount_flag, remount_flag);
+}
 
-Y_LOFF_T yaffs_freespace(const YCHAR *path)
+Y_LOFF_T yaffs_freespace_common(struct yaffs_dev *dev, const YCHAR *path)
 {
 	Y_LOFF_T retVal = -1;
-	struct yaffs_dev *dev = NULL;
 	YCHAR *dummy;
 
-	if (yaffsfs_CheckMemRegion(path, 0, 0) < 0) {
-		yaffsfs_SetError(-EFAULT);
-		return -1;
-	}
+	if (!dev) {
+		if (yaffsfs_CheckMemRegion(path, 0, 0) < 0) {
+			yaffsfs_SetError(-EFAULT);
+			return -1;
+		}
 
-	if (yaffsfs_CheckPath(path) < 0) {
-		yaffsfs_SetError(-ENAMETOOLONG);
-		return -1;
+		if (yaffsfs_CheckPath(path) < 0) {
+			yaffsfs_SetError(-ENAMETOOLONG);
+			return -1;
+		}
 	}
 
 	yaffsfs_Lock();
-	dev = yaffsfs_FindDevice(path, &dummy);
+	if (!dev)
+		dev = yaffsfs_FindDevice(path, &dummy);
 	if (dev && dev->is_mounted) {
 		retVal = yaffs_get_n_free_chunks(dev);
 		retVal *= dev->data_bytes_per_chunk;
@@ -2753,24 +3271,36 @@ Y_LOFF_T yaffs_freespace(const YCHAR *path)
 	return retVal;
 }
 
-Y_LOFF_T yaffs_totalspace(const YCHAR *path)
+Y_LOFF_T yaffs_freespace_reldev(struct yaffs_dev *dev)
+{
+	return yaffs_freespace_common(dev, NULL);
+}
+
+Y_LOFF_T yaffs_freespace(const YCHAR *path)
+{
+	return yaffs_freespace_common(NULL, path);
+}
+
+Y_LOFF_T yaffs_totalspace_common(struct yaffs_dev *dev, const YCHAR *path)
 {
 	Y_LOFF_T retVal = -1;
-	struct yaffs_dev *dev = NULL;
 	YCHAR *dummy;
 
-	if (yaffsfs_CheckMemRegion(path, 0, 0) < 0) {
-		yaffsfs_SetError(-EFAULT);
-		return -1;
-	}
+	if (!dev) {
+		if (yaffsfs_CheckMemRegion(path, 0, 0) < 0) {
+			yaffsfs_SetError(-EFAULT);
+			return -1;
+		}
 
-	if (yaffsfs_CheckPath(path) < 0) {
-		yaffsfs_SetError(-ENAMETOOLONG);
-		return -1;
+		if (yaffsfs_CheckPath(path) < 0) {
+			yaffsfs_SetError(-ENAMETOOLONG);
+			return -1;
+		}
 	}
 
 	yaffsfs_Lock();
-	dev = yaffsfs_FindDevice(path, &dummy);
+	if (!dev)
+		dev = yaffsfs_FindDevice(path, &dummy);
 	if (dev && dev->is_mounted) {
 		retVal = (dev->param.end_block - dev->param.start_block + 1) -
 		    dev->param.n_reserved_blocks;
@@ -2784,24 +3314,36 @@ Y_LOFF_T yaffs_totalspace(const YCHAR *path)
 	return retVal;
 }
 
-int yaffs_inodecount(const YCHAR *path)
+Y_LOFF_T yaffs_totalspace_reldev(struct yaffs_dev *dev)
+{
+	return yaffs_totalspace_common(dev, NULL);
+}
+
+Y_LOFF_T yaffs_totalspace(const YCHAR *path)
+{
+	return yaffs_totalspace_common(NULL, path);
+}
+
+int yaffs_inodecount_common(struct yaffs_dev *dev, const YCHAR *path)
 {
 	Y_LOFF_T retVal = -1;
-	struct yaffs_dev *dev = NULL;
 	YCHAR *dummy;
 
-	if (yaffsfs_CheckMemRegion(path, 0, 0) < 0) {
-		yaffsfs_SetError(-EFAULT);
-		return -1;
-	}
+	if (!dev) {
+		if (yaffsfs_CheckMemRegion(path, 0, 0) < 0) {
+			yaffsfs_SetError(-EFAULT);
+			return -1;
+		}
 
-	if (yaffsfs_CheckPath(path) < 0) {
-		yaffsfs_SetError(-ENAMETOOLONG);
-		return -1;
+		if (yaffsfs_CheckPath(path) < 0) {
+			yaffsfs_SetError(-ENAMETOOLONG);
+			return -1;
+		}
 	}
 
 	yaffsfs_Lock();
-	dev = yaffsfs_FindDevice(path, &dummy);
+	if (!dev)
+		dev = yaffsfs_FindDevice(path, &dummy);
 	if (dev && dev->is_mounted) {
 		int n_obj = dev->n_obj;
 		if (n_obj > dev->n_hardlinks)
@@ -2815,6 +3357,16 @@ int yaffs_inodecount(const YCHAR *path)
 	return retVal;
 }
 
+int yaffs_inodecount_reldev(struct yaffs_dev *dev)
+{
+	return yaffs_inodecount_common(dev, NULL);
+}
+
+int yaffs_inodecount(const YCHAR *path)
+{
+	return yaffs_inodecount_common(NULL, path);
+}
+
 void yaffs_add_device(struct yaffs_dev *dev)
 {
 	struct list_head *cfg;
@@ -2832,6 +3384,8 @@ void yaffs_add_device(struct yaffs_dev *dev)
 		INIT_LIST_HEAD(&dev->dev_list);
 
 	list_add(&dev->dev_list, &yaffsfs_deviceList);
+
+
 }
 
 void yaffs_remove_device(struct yaffs_dev *dev)
@@ -2865,7 +3419,7 @@ struct yaffs_dev *yaffs_next_dev(void)
 
 static struct list_head search_contexts;
 
-static void yaffsfs_SetDirRewound(struct yaffsfs_DirSearchContxt *dsc)
+static void yaffsfs_SetDirRewound(struct yaffsfs_DirSearchContext *dsc)
 {
 	if (dsc &&
 	    dsc->dirObj &&
@@ -2885,7 +3439,7 @@ static void yaffsfs_SetDirRewound(struct yaffsfs_DirSearchContxt *dsc)
 	}
 }
 
-static void yaffsfs_DirAdvance(struct yaffsfs_DirSearchContxt *dsc)
+static void yaffsfs_DirAdvance(struct yaffsfs_DirSearchContext *dsc)
 {
 	if (dsc &&
 	    dsc->dirObj &&
@@ -2913,7 +3467,7 @@ static void yaffsfs_RemoveObjectCallback(struct yaffs_obj *obj)
 {
 
 	struct list_head *i;
-	struct yaffsfs_DirSearchContxt *dsc;
+	struct yaffsfs_DirSearchContext *dsc;
 
 	/* if search contexts not initilised then skip */
 	if (!search_contexts.next)
@@ -2925,7 +3479,7 @@ static void yaffsfs_RemoveObjectCallback(struct yaffs_obj *obj)
 	 */
 	list_for_each(i, &search_contexts) {
 		if (i) {
-			dsc = list_entry(i, struct yaffsfs_DirSearchContxt,
+			dsc = list_entry(i, struct yaffsfs_DirSearchContext,
 					 others);
 			if (dsc->nextReturn == obj)
 				yaffsfs_DirAdvance(dsc);
@@ -2934,11 +3488,12 @@ static void yaffsfs_RemoveObjectCallback(struct yaffs_obj *obj)
 
 }
 
-yaffs_DIR *yaffs_opendir(const YCHAR *dirname)
+static yaffs_DIR *yaffsfs_opendir_reldir_no_lock(struct yaffs_obj *reldir,
+					const YCHAR *dirname)
 {
 	yaffs_DIR *dir = NULL;
 	struct yaffs_obj *obj = NULL;
-	struct yaffsfs_DirSearchContxt *dsc = NULL;
+	struct yaffsfs_DirSearchContext *dsc = NULL;
 	int notDir = 0;
 	int loop = 0;
 
@@ -2952,9 +3507,8 @@ yaffs_DIR *yaffs_opendir(const YCHAR *dirname)
 		return NULL;
 	}
 
-	yaffsfs_Lock();
-
-	obj = yaffsfs_FindObject(NULL, dirname, 0, 1, NULL, &notDir, &loop);
+	obj = yaffsfs_FindObject(reldir, dirname, 0, 1, NULL, &notDir, &loop);
+	obj = yaffsfs_FollowLink(obj, 0, &loop);
 
 	if (!obj && notDir)
 		yaffsfs_SetError(-ENOTDIR);
@@ -2975,7 +3529,7 @@ yaffs_DIR *yaffs_opendir(const YCHAR *dirname)
 		dir = (yaffs_DIR *) dsc;
 
 		if (dsc) {
-			memset(dsc, 0, sizeof(struct yaffsfs_DirSearchContxt));
+			memset(dsc, 0, sizeof(struct yaffsfs_DirSearchContext));
 			dsc->inUse = 1;
 			dsc->dirObj = obj;
 			yaffs_strncpy(dsc->name, dirname, NAME_MAX);
@@ -2987,21 +3541,37 @@ yaffs_DIR *yaffs_opendir(const YCHAR *dirname)
 			list_add(&dsc->others, &search_contexts);
 			yaffsfs_SetDirRewound(dsc);
 		}
-
 	}
+	return dir;
+}
 
+yaffs_DIR *yaffs_opendir_reldir(struct yaffs_obj *reldir, const YCHAR *dirname)
+{
+	yaffs_DIR *ret;
+
+	yaffsfs_Lock();
+	ret = yaffsfs_opendir_reldir_no_lock(reldir, dirname);
 	yaffsfs_Unlock();
+	return ret;
+}
 
-	return dir;
+yaffs_DIR *yaffs_opendir_reldev(struct yaffs_dev *dev, const YCHAR *dirname)
+{
+	return yaffs_opendir_reldir(ROOT_DIR(dev), dirname);
 }
 
-struct yaffs_dirent *yaffs_readdir(yaffs_DIR * dirp)
+yaffs_DIR *yaffs_opendir(const YCHAR *dirname)
 {
-	struct yaffsfs_DirSearchContxt *dsc;
+	return yaffs_opendir_reldir(NULL, dirname);
+}
+
+struct yaffs_dirent *yaffsfs_readdir_no_lock(yaffs_DIR * dirp)
+{
+	struct yaffsfs_DirSearchContext *dsc;
 	struct yaffs_dirent *retVal = NULL;
 
-	dsc = (struct yaffsfs_DirSearchContxt *) dirp;
-	yaffsfs_Lock();
+	dsc = (struct yaffsfs_DirSearchContext *) dirp;
+
 
 	if (dsc && dsc->inUse) {
 		yaffsfs_SetError(0);
@@ -3024,49 +3594,95 @@ struct yaffs_dirent *yaffs_readdir(yaffs_DIR * dirp)
 	} else
 		yaffsfs_SetError(-EBADF);
 
-	yaffsfs_Unlock();
-
 	return retVal;
 
 }
+struct yaffs_dirent *yaffs_readdir(yaffs_DIR * dirp)
+{
+	struct yaffs_dirent *ret;
 
-void yaffs_rewinddir(yaffs_DIR *dirp)
+	yaffsfs_Lock();
+	ret = yaffsfs_readdir_no_lock(dirp);
+	yaffsfs_Unlock();
+	return ret;
+}
+
+static void yaffsfs_rewinddir_no_lock(yaffs_DIR *dirp)
 {
-	struct yaffsfs_DirSearchContxt *dsc;
+	struct yaffsfs_DirSearchContext *dsc;
 
-	dsc = (struct yaffsfs_DirSearchContxt *) dirp;
+	dsc = (struct yaffsfs_DirSearchContext *) dirp;
 
 	if (yaffsfs_CheckMemRegion(dirp, sizeof(*dsc), 0) < 0)
 		return;
 
+	yaffsfs_SetDirRewound(dsc);
+
+}
+
+void yaffs_rewinddir(yaffs_DIR *dirp)
+{
 	yaffsfs_Lock();
+	yaffsfs_rewinddir_no_lock(dirp);
+	yaffsfs_Unlock();
+}
 
-	yaffsfs_SetDirRewound(dsc);
+struct yaffs_dirent *yaffs_readdir_fd(int fd)
+{
+	struct yaffs_dirent *ret = NULL;
+	struct yaffsfs_FileDes *f;
+
+	yaffsfs_Lock();
+	f = yaffsfs_HandleToFileDes(fd);
+	if(f && f->isDir)
+		ret = yaffsfs_readdir_no_lock(f->v.dir);
+	yaffsfs_Unlock();
+	return ret;
+}
+
+void yaffs_rewinddir_fd(int fd)
+{
+	struct yaffsfs_FileDes *f;
 
+	yaffsfs_Lock();
+	f = yaffsfs_HandleToFileDes(fd);
+	if(f && f->isDir)
+		yaffsfs_rewinddir_no_lock(f->v.dir);
 	yaffsfs_Unlock();
 }
 
-int yaffs_closedir(yaffs_DIR *dirp)
+
+static int yaffsfs_closedir_no_lock(yaffs_DIR *dirp)
 {
-	struct yaffsfs_DirSearchContxt *dsc;
+	struct yaffsfs_DirSearchContext *dsc;
 
-	dsc = (struct yaffsfs_DirSearchContxt *) dirp;
+	dsc = (struct yaffsfs_DirSearchContext *) dirp;
 
 	if (yaffsfs_CheckMemRegion(dirp, sizeof(*dsc), 0) < 0) {
 		yaffsfs_SetError(-EFAULT);
 		return -1;
 	}
 
-	yaffsfs_Lock();
 	dsc->inUse = 0;
 	list_del(&dsc->others);	/* unhook from list */
-	yaffsfs_Unlock();
+
 	return 0;
 }
 
+int yaffs_closedir(yaffs_DIR *dirp)
+{
+	int ret;
+
+	yaffsfs_Lock();
+	ret = yaffsfs_closedir_no_lock(dirp);
+	yaffsfs_Unlock();
+	return ret;
+}
+
 /* End of directory stuff */
 
-int yaffs_symlink(const YCHAR *oldpath, const YCHAR *newpath)
+int yaffs_symlink_reldir(struct yaffs_obj *reldir,
+		       const YCHAR *oldpath, const YCHAR *newpath)
 {
 	struct yaffs_obj *parent = NULL;
 	struct yaffs_obj *obj;
@@ -3088,7 +3704,7 @@ int yaffs_symlink(const YCHAR *oldpath, const YCHAR *newpath)
 	}
 
 	yaffsfs_Lock();
-	parent = yaffsfs_FindDirectory(NULL, newpath, &name, 0, &notDir, &loop);
+	parent = yaffsfs_FindDirectory(reldir, newpath, &name, 0, &notDir, &loop);
 	if (!parent && notDir)
 		yaffsfs_SetError(-ENOTDIR);
 	else if (loop)
@@ -3103,8 +3719,8 @@ int yaffs_symlink(const YCHAR *oldpath, const YCHAR *newpath)
 		obj = yaffs_create_symlink(parent, name, mode, 0, 0, oldpath);
 		if (obj)
 			retVal = 0;
-		else if (yaffsfs_FindObject
-			 (NULL, newpath, 0, 0, NULL, NULL, NULL))
+		else if (yaffsfs_FindObject(reldir, newpath, 0, 0,
+						NULL, NULL, NULL))
 			yaffsfs_SetError(-EEXIST);
 		else
 			yaffsfs_SetError(-ENOSPC);
@@ -3115,8 +3731,13 @@ int yaffs_symlink(const YCHAR *oldpath, const YCHAR *newpath)
 	return retVal;
 
 }
+int yaffs_symlink(const YCHAR *oldpath, const YCHAR *newpath)
+{
+	return yaffs_symlink_reldir(NULL, oldpath, newpath);
+}
 
-int yaffs_readlink(const YCHAR *path, YCHAR *buf, int bufsiz)
+int yaffs_readlink_reldir(struct yaffs_obj *reldir,const YCHAR *path,
+			YCHAR *buf, int bufsiz)
 {
 	struct yaffs_obj *obj = NULL;
 	struct yaffs_obj *dir = NULL;
@@ -3132,7 +3753,7 @@ int yaffs_readlink(const YCHAR *path, YCHAR *buf, int bufsiz)
 
 	yaffsfs_Lock();
 
-	obj = yaffsfs_FindObject(NULL, path, 0, 1, &dir, &notDir, &loop);
+	obj = yaffsfs_FindObject(reldir, path, 0, 1, &dir, &notDir, &loop);
 
 	if (!dir && notDir)
 		yaffsfs_SetError(-ENOTDIR);
@@ -3151,8 +3772,13 @@ int yaffs_readlink(const YCHAR *path, YCHAR *buf, int bufsiz)
 	yaffsfs_Unlock();
 	return retVal;
 }
+int yaffs_readlink(const YCHAR *path, YCHAR *buf, int bufsiz)
+{
+	return yaffs_readlink_reldir(NULL, path, buf, bufsiz);
+}
 
-int yaffs_link(const YCHAR *oldpath, const YCHAR *linkpath)
+int yaffs_link_reldir(struct yaffs_obj *reldir,
+			const YCHAR *oldpath, const YCHAR *linkpath)
 {
 	/* Creates a link called newpath to existing oldpath */
 	struct yaffs_obj *obj = NULL;
@@ -3179,10 +3805,10 @@ int yaffs_link(const YCHAR *oldpath, const YCHAR *linkpath)
 
 	yaffsfs_Lock();
 
-	obj = yaffsfs_FindObject(NULL, oldpath, 0, 1,
+	obj = yaffsfs_FindObject(reldir, oldpath, 0, 1,
 				 &obj_dir, &notDirObj, &objLoop);
-	lnk = yaffsfs_FindObject(NULL, linkpath, 0, 0, NULL, NULL, NULL);
-	lnk_dir = yaffsfs_FindDirectory(NULL, linkpath, &newname,
+	lnk = yaffsfs_FindObject(reldir, linkpath, 0, 0, NULL, NULL, NULL);
+	lnk_dir = yaffsfs_FindDirectory(reldir, linkpath, &newname,
 					0, &notDirLnk, &lnkLoop);
 
 	if ((!obj_dir && notDirObj) || (!lnk_dir && notDirLnk))
@@ -3216,17 +3842,33 @@ int yaffs_link(const YCHAR *oldpath, const YCHAR *linkpath)
 
 	return retVal;
 }
+int yaffs_link(const YCHAR *oldpath, const YCHAR *linkpath)
+{
+	return yaffs_link_reldir(NULL, oldpath, linkpath);
+}
 
-int yaffs_mknod(const YCHAR *pathname, mode_t mode, dev_t dev)
+int yaffs_mknod_reldir(struct yaffs_obj *reldir, const YCHAR *pathname,
+		     mode_t mode, dev_t dev_val)
 {
 	(void) pathname;
 	(void) mode;
-	(void) dev;
+	(void) dev_val;
+	(void) reldir;
 
 	yaffsfs_SetError(-EINVAL);
 	return -1;
 }
 
+int yaffs_mknod_reldev(struct yaffs_dev *dev, const YCHAR *pathname, mode_t mode, dev_t dev_val)
+{
+	return yaffs_mknod_reldir(ROOT_DIR(dev), pathname, mode, dev_val);
+}
+
+int yaffs_mknod(const YCHAR *pathname, mode_t mode, dev_t dev_val)
+{
+	return yaffs_mknod_reldir(NULL, pathname, mode, dev_val);
+}
+
 /*
  * D E B U G   F U N C T I O N S
  */
@@ -3235,7 +3877,7 @@ int yaffs_mknod(const YCHAR *pathname, mode_t mode, dev_t dev)
  * yaffs_n_handles()
  * Returns number of handles attached to the object
  */
-int yaffs_n_handles(const YCHAR *path)
+int yaffs_n_handles_reldir(struct yaffs_obj *reldir, const YCHAR *path)
 {
 	struct yaffs_obj *obj;
 
@@ -3249,7 +3891,7 @@ int yaffs_n_handles(const YCHAR *path)
 		return -1;
 	}
 
-	obj = yaffsfs_FindObject(NULL, path, 0, 1, NULL, NULL, NULL);
+	obj = yaffsfs_FindObject(reldir, path, 0, 1, NULL, NULL, NULL);
 
 	if (obj)
 		return yaffsfs_CountHandles(obj);
@@ -3257,6 +3899,11 @@ int yaffs_n_handles(const YCHAR *path)
 		return -1;
 }
 
+int yaffs_n_handles(const YCHAR *path)
+{
+	return yaffs_n_handles_reldir(NULL, path);
+}
+
 int yaffs_get_error(void)
 {
 	return yaffsfs_GetLastError();
@@ -3268,17 +3915,25 @@ int yaffs_set_error(int error)
 	return 0;
 }
 
-int yaffs_dump_dev(const YCHAR *path)
+struct yaffs_obj * yaffs_get_obj_from_fd(int handle)
+{
+	return yaffsfs_HandleToObject(handle);
+}
+
+int yaffs_dump_dev_reldir(struct yaffs_obj *reldir, const YCHAR *path)
 {
 #if 1
 	(void) path;
+	(void) reldir;
 #else
 	YCHAR *rest;
 
-	struct yaffs_obj *obj = yaffsfs_FindRoot(path, &rest);
 
-	if (obj) {
-		struct yaffs_dev *dev = obj->my_dev;
+	if (!reldir)
+		reldir = yaffsfs_FindRoot(path, &rest);
+
+	if (reldir) {
+		struct yaffs_dev *dev = reldir->my_dev;
 
 		printf("\n"
 		       "n_page_writes.......... %d\n"
@@ -3298,3 +3953,8 @@ int yaffs_dump_dev(const YCHAR *path)
 #endif
 	return 0;
 }
+
+int yaffs_dump_dev(const YCHAR *path)
+{
+	return yaffs_dump_dev_reldir(NULL, path);
+}