yaffs Add function to get number of open handles
[yaffs2.git] / direct / yaffsfs.c
index c4fc215..b709d93 100644 (file)
@@ -17,7 +17,7 @@
 #include "yportenv.h"
 #include "yaffs_trace.h"
 
-#include <string.h> // for memset
+#include <string.h> /* for memset */
 
 #define YAFFSFS_MAX_SYMLINK_DEREFERENCES 5
 
 #define YAFFSFS_RW_SHIFT (13)
 #define YAFFSFS_RW_SIZE  (1<<YAFFSFS_RW_SHIFT)
 
-
-const char *yaffsfs_c_version="$Id: yaffsfs.c,v 1.35 2010-02-25 22:38:03 charles Exp $";
-
-// configurationList is the list of devices that are supported
-static yaffsfs_DeviceConfiguration *yaffsfs_configurationList;
-
-
 /* Some forward references */
 static yaffs_Object *yaffsfs_FindObject(yaffs_Object *relativeDirectory, const YCHAR *path, int symDepth);
 static void yaffsfs_RemoveObjectCallback(yaffs_Object *obj);
 
-
-// Handle management.
-//
-
-
 unsigned int yaffs_wr_attempts;
 
+/*
+ * Handle management.
+ * There are open inodes in yaffsfs_Inode.
+ * There are open handles in yaffsfs_Handle.
+ *
+ * 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.
+ */
+
 typedef struct {
-       int count;
+       int count;      /* Number of handles accessing this inode */
        yaffs_Object *iObj;
 } yaffsfs_Inode;
 
 typedef struct{
-       __u8    readOnly:1;     // this handle is read only
-       __u8    append:1;       // append only
-       int     inodeId:13;     // the object
-       int     useCount:16;    // Use count for this handle
-       __u32 position;         // current position in file
+       __u8    readOnly:1;
+       __u8    append:1;
+       int     inodeId:13;     /* Index to corresponding yaffsfs_Inode */
+       int     useCount:16;    /* Use count for this handle */
+       __u32 position;         /* current position in file */
 }yaffsfs_Handle;
 
 static yaffsfs_Inode yaffsfs_inode[YAFFSFS_N_HANDLES];
 static yaffsfs_Handle yaffsfs_handle[YAFFSFS_N_HANDLES];
+static int yaffsfs_handlesInitialised;
 
-// yaffsfs_InitHandle
-/// Inilitalise handles on start-up.
-//
-static int yaffsfs_InitHandles(void)
+/*
+ * yaffsfs_InitHandle
+ * Inilitalise handle management on start-up.
+ */
+
+static void yaffsfs_InitHandles(void)
 {
        int i;
+       if(yaffsfs_handlesInitialised)
+                return;
+
        memset(yaffsfs_inode,0,sizeof(yaffsfs_inode));
        memset(yaffsfs_handle,0,sizeof(yaffsfs_handle));
        for(i = 0; i < YAFFSFS_N_HANDLES; i++)
                yaffsfs_handle[i].inodeId = -1;
-
-       return 0;
 }
 
 yaffsfs_Handle *yaffsfs_GetHandlePointer(int h)
@@ -106,31 +109,47 @@ yaffs_Object *yaffsfs_GetHandleObject(int handle)
        return NULL;
 }
 
-//yaffsfs_GetInodeIdForObject
-// Grab an inode entry when opening a new inode.
-//
+/*
+ * yaffsfs_FindInodeIdForObject
+ * Find the inode entry for an object, if it exists.
+ */
 
-static int yaffsfs_GetInodeIdForObject(yaffs_Object *obj)
+static int yaffsfs_FindInodeIdForObject(yaffs_Object *obj)
 {
        int i;
        int ret = -1;
-       yaffsfs_Inode *in = NULL;
        
        if(obj)
                obj = yaffs_GetEquivalentObject(obj);
 
-       /* Look for it. If we can't find it then make one */
+       /* Look for it in open inode table*/
        for(i = 0; i < YAFFSFS_N_HANDLES && ret < 0; i++){
                if(yaffsfs_inode[i].iObj == obj)
                        ret = i;
        }
+       return ret;
+}
+
+/*
+ * yaffsfs_GetInodeIdForObject
+ * Grab an inode entry when opening a new inode.
+ */
+static int yaffsfs_GetInodeIdForObject(yaffs_Object *obj)
+{
+       int i;
+       int ret;
+       yaffsfs_Inode *in = NULL;
+       
+       if(obj)
+               obj = yaffs_GetEquivalentObject(obj);
+
+        ret = yaffsfs_FindInodeIdForObject(obj);
 
        for(i = 0; i < YAFFSFS_N_HANDLES && ret < 0; i++){
                if(!yaffsfs_inode[i].iObj)
                        ret = i;
        }
-       
-       
+
        if(ret>=0){
                in = &yaffsfs_inode[ret];
                if(!in->iObj)
@@ -143,6 +162,17 @@ static int yaffsfs_GetInodeIdForObject(yaffs_Object *obj)
        return ret;
 }
 
+
+static int yaffsfs_CountHandles(yaffs_Object *obj)
+{
+       int i = yaffsfs_FindInodeIdForObject(obj);
+
+       if(i >= 0)
+               return yaffsfs_inode[i].count;
+       else
+               return 0;
+}
+
 static void yaffsfs_ReleaseInode(yaffsfs_Inode *in)
 {
        yaffs_Object *obj;
@@ -168,9 +198,10 @@ static void yaffsfs_PutInode(int inodeId)
 }
 
 
-//yaffsfs_GetHandle
-// Grab a handle (when opening a file)
-//
+/*
+ * yaffsfs_GetHandle
+ * Grab a handle (when opening a file)
+ */
 
 static int yaffsfs_GetNewHandle(void)
 {
@@ -180,7 +211,7 @@ static int yaffsfs_GetNewHandle(void)
        for(i = 0; i < YAFFSFS_N_HANDLES; i++){
                h = yaffsfs_GetHandlePointer(i);
                if(!h){
-                       // todo bug: should never happen
+                       /* todo bug: should never happen */
                }
                if(h->useCount < 1){
                        memset(h,0,sizeof(yaffsfs_Handle));
@@ -192,8 +223,10 @@ static int yaffsfs_GetNewHandle(void)
        return -1;
 }
 
-// yaffs_GetHandle
-// Increase use of handle when reading/writing a file
+/*
+ * yaffs_GetHandle
+ * Increase use of handle when reading/writing a file
+ */
 static int yaffsfs_GetHandle(int handle)
 {
        yaffsfs_Handle *h = yaffsfs_GetHandlePointer(handle);
@@ -204,10 +237,11 @@ static int yaffsfs_GetHandle(int handle)
        return 0;
 }
 
-// yaffs_PutHandle
-// Let go of a handle when closing a file or aborting an open or
-// ending a read or write.
-//
+/*
+ * yaffs_PutHandle
+ * Let go of a handle when closing a file or aborting an open or
+ * ending a read or write.
+ */
 static int yaffsfs_PutHandle(int handle)
 {
        yaffsfs_Handle *h = yaffsfs_GetHandlePointer(handle);
@@ -227,18 +261,20 @@ static int yaffsfs_PutHandle(int handle)
 
 
 
-// Stuff to search for a directory from a path
+/*
+ *  Stuff to search for a directory from a path
+ */
 
 
 int yaffsfs_Match(YCHAR a, YCHAR b)
 {
-       // case sensitive
+       /* case sensitive */
        return (a == b);
 }
 
 int yaffsfs_IsPathDivider(YCHAR ch)
 {
-       YCHAR *str = YAFFS_PATH_DIVIDERS;
+       const YCHAR *str = YAFFS_PATH_DIVIDERS;
 
        while(*str){
                if(*str == ch)
@@ -249,41 +285,51 @@ int yaffsfs_IsPathDivider(YCHAR ch)
        return 0;
 }
 
-// yaffsfs_FindDevice
-// yaffsfs_FindRoot
-// Scan the configuration list to find the root.
-// Curveballs: Should match paths that end in '/' too
-// Curveball2 Might have "/x/ and "/x/y". Need to return the longest match
+
+
+YLIST_HEAD(yaffsfs_deviceList);
+
+/*
+ * yaffsfs_FindDevice
+ * yaffsfs_FindRoot
+ * Scan the configuration list to find the root.
+ * 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)
 {
-       yaffsfs_DeviceConfiguration *cfg = yaffsfs_configurationList;
+       struct ylist_head *cfg;
        const YCHAR *leftOver;
        const YCHAR *p;
        yaffs_Device *retval = NULL;
+       yaffs_Device *dev = NULL;
        int thisMatchLength;
        int longestMatch = -1;
        int matching;
 
-       // 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){
+       /*
+        * Check all configs, choose the one that:
+        * 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);
                leftOver = path;
-               p = cfg->prefix;
+               p = dev->param.name;
                thisMatchLength = 0;
                matching = 1;
 
 
                while(matching && *p && *leftOver){
-                       // Skip over any /s
+                       /* Skip over any /s */
                        while(yaffsfs_IsPathDivider(*p))
                              p++;
 
-                       // Skip over any /s
+                       /* Skip over any /s */
                        while(yaffsfs_IsPathDivider(*leftOver))
                              leftOver++;
 
-                       // Now match the text part
+                       /* Now match the text part */
                        while(matching &&
                              *p && !yaffsfs_IsPathDivider(*p) &&
                              *leftOver && !yaffsfs_IsPathDivider(*leftOver)){
@@ -297,19 +343,26 @@ static yaffs_Device *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPath)
                        }
                }
 
-               // Skip over any /s in leftOver
+               /* Skip over any /s in leftOver */
                while(yaffsfs_IsPathDivider(*leftOver))
                      leftOver++;
-               
 
-               if( matching && (thisMatchLength > longestMatch)){
+               // Skip over any /s in p
+               while(yaffsfs_IsPathDivider(*p))
+                     p++;
+
+               // p should now be at the end of the string (ie. fully matched)
+               if(*p)
+                       matching = 0;
+
+               if( matching && (thisMatchLength > longestMatch))
+               {
                        // Matched prefix
                        *restOfPath = (YCHAR *)leftOver;
-                       retval = cfg->dev;
+                       retval = dev;
                        longestMatch = thisMatchLength;
                }
 
-               cfg++;
        }
        return retval;
 }
@@ -324,28 +377,29 @@ static yaffs_Device *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPath)
        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.
+       /*
+        * 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)) && // the rest of the prefix is not / (to catch / at end)
-                     *leftOver &&
-                     yaffsfs_Match(*p,*leftOver)){
+               while(*p &&  /* unmatched part of prefix */
+                     !(yaffsfs_IsPathDivider(*p) && (p[1] == 0)) &&
+                     *leftOver && yaffsfs_Match(*p,*leftOver)){
                        p++;
                        leftOver++;
                        thisMatchLength++;
                }
 
 
-               if((!*p || (yaffsfs_IsPathDivider(*p) && (p[1] == 0))) &&      // end of prefix
-                  (!*leftOver || yaffsfs_IsPathDivider(*leftOver)) && // no more in this path name part
+               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
+                       /* Matched prefix */
                        *restOfPath = (YCHAR *)leftOver;
                        retval = cfg->dev;
                        longestMatch = thisMatchLength;
@@ -375,21 +429,24 @@ static yaffs_Object *yaffsfs_FollowLink(yaffs_Object *obj,int symDepth)
                YCHAR *alias = obj->variant.symLinkVariant.alias;
 
                if(yaffsfs_IsPathDivider(*alias))
-                       // Starts with a /, need to scan from root up
+                       /* Starts with a /, need to scan from root up */
                        obj = yaffsfs_FindObject(NULL,alias,symDepth++);
                else
-                       // Relative to here, so use the parent of the symlink as a start
+                       /* Relative to here, so use the parent of the symlink as a start */
                        obj = yaffsfs_FindObject(obj->parent,alias,symDepth++);
        }
        return obj;
 }
 
 
-// yaffsfs_FindDirectory
-// Parse a path to determine the directory and the name within the directory.
-//
-// 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)
+/*
+ * yaffsfs_FindDirectory
+ * Parse a path to determine the directory and the name within the directory.
+ *
+ * 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)
 {
        yaffs_Object *dir;
        YCHAR *restOfPath;
@@ -407,11 +464,13 @@ static yaffs_Object *yaffsfs_DoFindDirectory(yaffs_Object *startDir,const YCHAR
                dir = yaffsfs_FindRoot(path,&restOfPath);
 
        while(dir){
-               // parse off /.
-               // curve ball: also throw away surplus '/'
-               // eg. "/ram/x////ff" gets treated the same as "/ram/x/ff"
+               /*
+                * parse off /.
+                * curve ball: also throw away surplus '/'
+                * eg. "/ram/x////ff" gets treated the same as "/ram/x/ff"
+                */
                while(yaffsfs_IsPathDivider(*restOfPath))
-                       restOfPath++; // get rid of '/'
+                       restOfPath++; /* get rid of '/' */
 
                *name = restOfPath;
                i = 0;
@@ -426,12 +485,12 @@ static yaffs_Object *yaffsfs_DoFindDirectory(yaffs_Object *startDir,const YCHAR
                }
 
                if(!*restOfPath)
-                       // got to the end of the string
+                       /* got to the end of the string */
                        return dir;
                else{
                        if(yaffs_strcmp(str,_Y(".")) == 0)
                        {
-                               // Do nothing
+                               /* Do nothing */
                        }
                        else if(yaffs_strcmp(str,_Y("..")) == 0)
                                dir = dir->parent;
@@ -447,17 +506,19 @@ static yaffs_Object *yaffsfs_DoFindDirectory(yaffs_Object *startDir,const YCHAR
                        }
                }
        }
-       // directory did not exist.
+       /* directory did not exist. */
        return NULL;
 }
 
-static yaffs_Object *yaffsfs_FindDirectory(yaffs_Object *relativeDirectory,const YCHAR *path,YCHAR **name,int symDepth)
+static yaffs_Object *yaffsfs_FindDirectory(yaffs_Object *relativeDirectory,
+                                       const YCHAR *path,YCHAR **name,int symDepth)
 {
        return yaffsfs_DoFindDirectory(relativeDirectory,path,name,symDepth);
 }
 
-// yaffsfs_FindObject turns a path for an existing object into the object
-//
+/*
+ * 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)
 {
        yaffs_Object *dir;
@@ -531,7 +592,7 @@ int yaffs_open(const YCHAR *path, int oflag, int mode)
                h = yaffsfs_GetHandlePointer(handle);
 
 
-               // try to find the exisiting object
+               /* try to find the exisiting object */
                obj = yaffsfs_FindObject(NULL,path,0);
 
                if(obj && obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK)
@@ -540,23 +601,33 @@ int yaffs_open(const YCHAR *path, int oflag, int mode)
                if(obj)
                        obj = yaffs_GetEquivalentObject(obj);
 
-               if(obj && obj->variantType != YAFFS_OBJECT_TYPE_FILE)
+               if(obj &&
+                       obj->variantType != YAFFS_OBJECT_TYPE_FILE &&
+                       obj->variantType != YAFFS_OBJECT_TYPE_DIRECTORY)
                        obj = NULL;
 
                if(obj){
 
-                       /* The file already exists */
+                       /* The file already exists or it might be a directory */
 
-                       // Open should fail if O_CREAT and O_EXCL are specified since
-                       // the file exists
+                       /* If it is a directory then we can't open it as a file */
+                       if(obj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY){
+                               openDenied = 1;
+                               yaffsfs_SetError(-EISDIR);
+                               errorReported = 1;
+                       }
+
+                       /* Open should fail if O_CREAT and O_EXCL are specified since
+                        * the file exists
+                        */
                        if((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
+                       /* Check file permissions */
+                       if( (oflag & (O_RDWR | O_WRONLY)) == 0 &&     /* ie O_RDONLY */
                           !(obj->yst_mode & S_IREAD))
                                openDenied = 1;
 
@@ -569,7 +640,7 @@ int yaffs_open(const YCHAR *path, int oflag, int mode)
                                openDenied = 1;
 
                } else if((oflag & O_CREAT)) {
-                       // Let's see if we can create this file
+                       /* Let's see if we can create this file */
                        dir = yaffsfs_FindDirectory(NULL,path,&name,0);
                        if(dir  && dir->myDev->readOnly){
                                yaffsfs_SetError(-EINVAL);
@@ -627,10 +698,10 @@ int yaffs_Dofsync(int fd,int datasync)
        h = yaffsfs_GetHandlePointer(fd);
 
        if(h && h->useCount > 0)
-               // flush the file
+               /* flush the file */
                yaffs_FlushFile(yaffsfs_inode[h->inodeId].iObj,1,datasync);
        else {
-               // bad handle
+               /* bad handle */
                yaffsfs_SetError(-EBADF);
                retVal = -1;
        }
@@ -665,12 +736,12 @@ int yaffs_close(int fd)
        h = yaffsfs_GetHandlePointer(fd);
 
        if(h && h->useCount > 0) {
-               // clean up
+               /* clean up */
                yaffs_FlushFile(yaffsfs_inode[h->inodeId].iObj,1,0);
                yaffsfs_PutHandle(fd);
                retVal = 0;
        } else {
-               // bad handle
+               /* bad handle */
                yaffsfs_SetError(-EBADF);
                retVal = -1;
        }
@@ -699,7 +770,7 @@ int yaffsfs_do_read(int fd, void *vbuf, unsigned int nbyte, int isPread, int off
        obj = yaffsfs_GetHandleObject(fd);
 
        if(!h || !obj){
-               // bad handle
+               /* bad handle */
                yaffsfs_SetError(-EBADF);
                totalRead = -1;
        } else if( h && obj){
@@ -752,7 +823,7 @@ int yaffsfs_do_read(int fd, void *vbuf, unsigned int nbyte, int isPread, int off
                        if(totalRead >= 0)
                                h->position = startPos + totalRead;
                        else {
-                                       //todo error
+                                       /* todo error */
                        }
                }
 
@@ -791,17 +862,17 @@ int yaffsfs_do_write(int fd, const void *vbuf, unsigned int nbyte, int isPwrite,
        obj = yaffsfs_GetHandleObject(fd);
 
        if(!h || !obj){
-               // bad handle
+               /* bad handle */
                yaffsfs_SetError(-EBADF);
                totalWritten = -1;
        } else if( h && obj && (h->readOnly || obj->myDev->readOnly)){
                yaffsfs_SetError(-EINVAL);
                totalWritten=-1;
        } else if( h && obj){
-               if(isPwrite)
-                       startPos = offset;
                if(h->append)
                        startPos = yaffs_GetObjectFileLength(obj);
+               else if(isPwrite)
+                       startPos = offset;
                else
                        startPos = h->position;
 
@@ -841,7 +912,7 @@ int yaffsfs_do_write(int fd, const void *vbuf, unsigned int nbyte, int isPwrite,
                        if(totalWritten > 0)
                                h->position = startPos + totalWritten;
                        else {
-                               //todo error
+                               /* todo error */
                        }
                }
        }
@@ -899,12 +970,12 @@ int yaffs_ftruncate(int fd, off_t newSize)
        obj = yaffsfs_GetHandleObject(fd);
 
        if(!h || !obj)
-               // bad handle
+               /* bad handle */
                yaffsfs_SetError(-EBADF);
        else if(obj->myDev->readOnly)
                yaffsfs_SetError(-EINVAL);
        else
-               // resize the file
+               /* resize the file */
                result = yaffs_ResizeFile(obj,newSize);
        yaffsfs_Unlock();
 
@@ -925,7 +996,7 @@ off_t yaffs_lseek(int fd, off_t offset, int whence)
        obj = yaffsfs_GetHandleObject(fd);
 
        if(!h || !obj)
-               // bad handle
+               /* bad handle */
                yaffsfs_SetError(-EBADF);
        else if(whence == SEEK_SET){
                if(offset >= 0)
@@ -944,7 +1015,7 @@ off_t yaffs_lseek(int fd, off_t offset, int whence)
        if(pos >= 0)
                h->position = pos;
        else {
-               // todo error
+               /* todo error */
        }
 
 
@@ -984,7 +1055,7 @@ int yaffsfs_DoUnlink(const YCHAR *path,int isDirectory)
 
        yaffsfs_Unlock();
 
-       // todo error
+       /* todo error */
 
        return (result == YAFFS_FAIL) ? -1 : 0;
 }
@@ -1017,21 +1088,23 @@ int yaffs_rename(const YCHAR *oldPath, const YCHAR *newPath)
        obj = yaffsfs_FindObject(NULL,oldPath,0);
 
        if(!olddir || !newdir || !obj) {
-               // bad file
+               /* bad file */
                yaffsfs_SetError(-EBADF);
                renameAllowed = 0;
        } else if(obj->myDev->readOnly){
                yaffsfs_SetError(-EINVAL);
                renameAllowed = 0;
        } else if(olddir->myDev != newdir->myDev) {
-               // oops must be on same device
-               // todo error
+               /* oops must be on same device */
+               /* todo error */
                yaffsfs_SetError(-EXDEV);
                renameAllowed = 0;
        } else if(obj && obj->variantType == 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
+               /*
+                * 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
+                */
 
                yaffs_Object *xx = newdir;
 
@@ -1061,9 +1134,9 @@ static int yaffsfs_DoStat(yaffs_Object *obj,struct yaffs_stat *buf)
                obj = yaffs_GetEquivalentObject(obj);
 
        if(obj && buf){
-               buf->st_dev = (int)obj->myDev->context;
+               buf->st_dev = (int)obj->myDev->osContext;
                buf->st_ino = obj->objectId;
-               buf->st_mode = obj->yst_mode & ~S_IFMT; // clear out file type bits
+               buf->st_mode = obj->yst_mode & ~S_IFMT; /* clear out file type bits */
 
                if(obj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY)
                        buf->st_mode |= S_IFDIR;
@@ -1111,7 +1184,7 @@ static int yaffsfs_DoStatOrLStat(const YCHAR *path, struct yaffs_stat *buf,int d
        if(obj)
                retVal = yaffsfs_DoStat(obj,buf);
        else
-               // todo error not found
+               /* todo error not found */
                yaffsfs_SetError(-ENOENT);
 
        yaffsfs_Unlock();
@@ -1142,13 +1215,269 @@ int yaffs_fstat(int fd, struct yaffs_stat *buf)
        if(obj)
                retVal = yaffsfs_DoStat(obj,buf);
        else
-               // bad handle
+               /* 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)
+{
+       yaffs_Object *obj;
+
+       int retVal = -1;
+
+       yaffsfs_Lock();
+       obj = yaffsfs_FindObject(NULL,path,0);
+
+       if(follow)
+               obj = yaffsfs_FollowLink(obj,0);
+
+       if(obj) {
+               retVal = yaffs_SetXAttribute(obj,name,data,size,flags);
+               if(retVal< 0){
+                       yaffsfs_SetError(retVal);
+                       retVal = -1;
+               }
+       } else
+               /* todo error not found */
+               yaffsfs_SetError(-ENOENT);
+
+       yaffsfs_Unlock();
+
+       return retVal;
+
+}
+
+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);
+}
+
+int yaffs_lsetxattr(const YCHAR *path, const char *name, const void *data, int size, int flags)
+{
+       return yaffs_do_setxattr(path, name, data, size, flags, 0);
+}
+
+
+
+int yaffs_fsetxattr(int fd, const char *name, const void *data, int size, int flags)
+{
+       yaffs_Object *obj;
+
+       int retVal = -1;
+
+       yaffsfs_Lock();
+       obj = yaffsfs_GetHandleObject(fd);
+
+       if(obj) {
+               retVal = yaffs_SetXAttribute(obj,name,data,size,flags);
+               if(retVal< 0){
+                       yaffsfs_SetError(retVal);
+                       retVal = -1;
+               }
+       } else
+               /* bad handle */
+               yaffsfs_SetError(-EBADF);
+
+       yaffsfs_Unlock();
+
+       return retVal;
+}
+
+static int yaffs_do_getxattr(const YCHAR *path, const char *name, void *data, int size, int follow)
+{
+       yaffs_Object *obj;
+
+       int retVal = -1;
+
+       yaffsfs_Lock();
+       obj = yaffsfs_FindObject(NULL,path,0);
+
+       if(follow)
+               obj = yaffsfs_FollowLink(obj,0);
+
+       if(obj) {
+               retVal = yaffs_GetXAttribute(obj,name,data,size);
+               if(retVal< 0){
+                       yaffsfs_SetError(retVal);
+                       retVal = -1;
+               }
+       } else
+               /* todo error not found */
+               yaffsfs_SetError(-ENOENT);
+
+       yaffsfs_Unlock();
+
+       return retVal;
+
+}
+
+int yaffs_getxattr(const YCHAR *path, const char *name, void *data, int size)
+{
+       return yaffs_do_getxattr( path, name, data, size, 1);
+}
+int yaffs_lgetxattr(const YCHAR *path, const char *name, void *data, int size)
+{
+       return yaffs_do_getxattr( path, name, data, size, 0);
+}
+
+
+
+int yaffs_fgetxattr(int fd, const char *name, void *data, int size)
+{
+       yaffs_Object *obj;
+
+       int retVal = -1;
+
+       yaffsfs_Lock();
+       obj = yaffsfs_GetHandleObject(fd);
+
+       if(obj) {
+               retVal = yaffs_GetXAttribute(obj,name,data,size);
+               if(retVal< 0){
+                       yaffsfs_SetError(retVal);
+                       retVal = -1;
+               }
+       } else
+               /* bad handle */
+               yaffsfs_SetError(-EBADF);
+
+       yaffsfs_Unlock();
+
+       return retVal;
+}
+
+static int yaffs_do_listxattr(const YCHAR *path, char *data, int size, int follow)
+{
+       yaffs_Object *obj;
+
+       int retVal = -1;
+
+       yaffsfs_Lock();
+       obj = yaffsfs_FindObject(NULL,path,0);
+
+       if(follow)
+               obj = yaffsfs_FollowLink(obj,0);
+
+       if(obj) {
+               retVal = yaffs_ListXAttributes(obj, data,size);
+               if(retVal< 0){
+                       yaffsfs_SetError(retVal);
+                       retVal = -1;
+               }
+       } else
+               /* todo error not found */
+               yaffsfs_SetError(-ENOENT);
+
+       yaffsfs_Unlock();
+
+       return retVal;
+
+}
+
+int yaffs_listxattr(const YCHAR *path, char *data, int size)
+{
+       return yaffs_do_listxattr(path, data, size, 1);
+}
+
+int yaffs_llistxattr(const YCHAR *path, char *data, int size)
+{
+       return yaffs_do_listxattr(path, data, size, 0);
+}
+
+int yaffs_flistxattr(int fd, char *data, int size)
+{
+       yaffs_Object *obj;
+
+       int retVal = -1;
+
+       yaffsfs_Lock();
+       obj = yaffsfs_GetHandleObject(fd);
+
+       if(obj) {
+               retVal = yaffs_ListXAttributes(obj,data,size);
+               if(retVal< 0){
+                       yaffsfs_SetError(retVal);
+                       retVal = -1;
+               }
+       } else
+               /* bad handle */
+               yaffsfs_SetError(-EBADF);
+
+       yaffsfs_Unlock();
+
+       return retVal;
+}
+
+static int yaffs_do_removexattr(const YCHAR *path, const char *name, int follow)
+{
+       yaffs_Object *obj;
+
+       int retVal = -1;
+
+       yaffsfs_Lock();
+       obj = yaffsfs_FindObject(NULL,path,0);
+
+       if(follow)
+               obj = yaffsfs_FollowLink(obj,0);
+
+       if(obj) {
+               retVal = yaffs_RemoveXAttribute(obj,name);
+               if(retVal< 0){
+                       yaffsfs_SetError(retVal);
+                       retVal = -1;
+               }
+       } else
+               /* todo error not found */
+               yaffsfs_SetError(-ENOENT);
+
+       yaffsfs_Unlock();
+
+       return retVal;
+
+}
+
+int yaffs_removexattr(const YCHAR *path, const char *name)
+{
+       return yaffs_do_removexattr(path, name, 1);
+}
+
+int yaffs_lremovexattr(const YCHAR *path, const char *name)
+{
+       return yaffs_do_removexattr(path, name, 0);
+}
+
+int yaffs_fremovexattr(int fd, const char *name)
+{
+       yaffs_Object *obj;
+
+       int retVal = -1;
+
+       yaffsfs_Lock();
+       obj = yaffsfs_GetHandleObject(fd);
+
+       if(obj){
+               retVal = yaffs_RemoveXAttribute(obj,name);
+               if(retVal< 0){
+                       yaffsfs_SetError(retVal);
+                       retVal = -1;
+               }
+       }else
+               /* bad handle */
                yaffsfs_SetError(-EBADF);
 
        yaffsfs_Unlock();
 
        return retVal;
 }
+#endif
 
 #ifdef CONFIG_YAFFS_WINCE
 int yaffs_get_wince_times(int fd, unsigned *wctime, unsigned *watime, unsigned *wmtime)
@@ -1178,7 +1507,7 @@ int yaffs_get_wince_times(int fd, unsigned *wctime, unsigned *watime, unsigned *
 
                retVal = 0;
        } else
-               // bad handle
+               /*  bad handle */
                yaffsfs_SetError(-EBADF);               
        
        yaffsfs_Unlock();
@@ -1218,7 +1547,7 @@ int yaffs_set_wince_times(int fd,
                 result = yaffs_FlushFile(obj,0,0);
                 retVal = 0;
         } else
-               // bad handle
+               /* bad handle */
                yaffsfs_SetError(-EBADF);
 
        yaffsfs_Unlock();
@@ -1270,7 +1599,7 @@ int yaffs_access(const YCHAR *path, int amode)
                        retval = -1;
                }
        } else {
-               // todo error not found
+               /* todo error not found */
                yaffsfs_SetError(-ENOENT);
                retval = -1;
        }
@@ -1336,7 +1665,10 @@ int yaffs_mkdir(const YCHAR *path, mode_t mode)
 
        yaffsfs_Lock();
        parent = yaffsfs_FindDirectory(NULL,path,&name,0);
-       if(parent && parent->myDev->readOnly){
+       if(parent && 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)
@@ -1345,11 +1677,11 @@ int yaffs_mkdir(const YCHAR *path, mode_t mode)
                        retVal = 0;
                else {
                        if(!parent)
-                               yaffsfs_SetError(-ENOENT); // missing path
+                               yaffsfs_SetError(-ENOENT); /* missing path */
                        else if (yaffs_FindObjectByName(parent,name))
-                               yaffsfs_SetError(-EEXIST); // the name already exists
+                               yaffsfs_SetError(-EEXIST); /* the name already exists */
                        else
-                               yaffsfs_SetError(-ENOSPC); // just assume no space
+                               yaffsfs_SetError(-ENOSPC); /* just assume no space */
                        retVal = -1;
                }
        }
@@ -1359,6 +1691,14 @@ int yaffs_mkdir(const YCHAR *path, mode_t mode)
        return retVal;
 }
 
+void * yaffs_getdev(const YCHAR *path)
+{
+       yaffs_Device *dev=NULL;
+       YCHAR *dummy;
+       dev = yaffsfs_FindDevice(path,&dummy);
+       return (void *)dev;
+}
+
 int yaffs_mount2(const YCHAR *path,int readOnly)
 {
        int retVal=-1;
@@ -1369,22 +1709,25 @@ int yaffs_mount2(const YCHAR *path,int readOnly)
        T(YAFFS_TRACE_ALWAYS,(TSTR("yaffs: Mounting %s" TENDSTR),path));
 
        yaffsfs_Lock();
+
+       yaffsfs_InitHandles();
+
        dev = yaffsfs_FindDevice(path,&dummy);
        if(dev){
                if(!dev->isMounted){
                        dev->readOnly = readOnly ? 1 : 0;
                        result = yaffs_GutsInitialise(dev);
                        if(result == YAFFS_FAIL)
-                               // todo error - mount failed
+                               /* todo error - mount failed */
                                yaffsfs_SetError(-ENOMEM);
                        retVal = result ? 0 : -1;
 
                }
                else
-                       //todo error - already mounted.
+                       /* todo error - already mounted. */
                        yaffsfs_SetError(-EBUSY);
        } else
-               // todo error - no device
+               /* todo error - no device */
                yaffsfs_SetError(-ENODEV);
 
        yaffsfs_Unlock();
@@ -1410,14 +1753,14 @@ int yaffs_sync(const YCHAR *path)
                         
                         yaffs_FlushEntireDeviceCache(dev);
                         yaffs_CheckpointSave(dev);
-                        
+                        retVal = 0;
                         
                 } else
-                        //todo error - not mounted.
+                        /* todo error - not mounted. */
                         yaffsfs_SetError(-EINVAL);
                         
         }else
-                // todo error - no device
+                /* todo error - no device */
                 yaffsfs_SetError(-ENODEV);
 
         yaffsfs_Unlock();
@@ -1442,7 +1785,7 @@ int yaffs_remount(const YCHAR *path, int force, int readOnly)
 
                        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
+                                       inUse = 1; /* the device is in use, can't unmount */
                        }
 
                        if(!inUse || force){
@@ -1483,7 +1826,7 @@ int yaffs_unmount2(const YCHAR *path, int force)
 
                        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
+                                       inUse = 1; /* the device is in use, can't unmount */
                        }
 
                        if(!inUse || force){
@@ -1491,16 +1834,16 @@ int yaffs_unmount2(const YCHAR *path, int force)
 
                                retVal = 0;
                        } else
-                               // todo error can't unmount as files are open
+                               /* todo error can't unmount as files are open */
                                yaffsfs_SetError(-EBUSY);
 
                } else
-                       //todo error - not mounted.
+                       /* todo error - not mounted. */
                        yaffsfs_SetError(-EINVAL);
 
        }
        else
-               // todo error - no device
+               /* todo error - no device */
                yaffsfs_SetError(-ENODEV);
 
        yaffsfs_Unlock();
@@ -1561,7 +1904,7 @@ int yaffs_inodecount(const YCHAR *path)
        yaffsfs_Lock();
        dev = yaffsfs_FindDevice(path,&dummy);
        if(dev  && dev->isMounted) {
-          int nObjects = dev->nObjectsCreated - dev->nFreeObjects;
+          int nObjects = dev->nObjects;
           if(nObjects > dev->nHardLinks)
                retVal = nObjects - dev->nHardLinks;
        }
@@ -1574,35 +1917,32 @@ int yaffs_inodecount(const YCHAR *path)
 }
 
 
-
-void yaffs_initialise(yaffsfs_DeviceConfiguration *cfgList)
+void yaffs_AddDevice(yaffs_Device *dev)
 {
+       dev->isMounted = 0;
+       dev->param.removeObjectCallback = yaffsfs_RemoveObjectCallback;
 
-       yaffsfs_DeviceConfiguration *cfg;
-
-       yaffsfs_configurationList = cfgList;
-
-       yaffsfs_InitHandles();
+       if(!dev->devList.next)
+               YINIT_LIST_HEAD(&dev->devList);
 
-       cfg = yaffsfs_configurationList;
+       ylist_add(&dev->devList,&yaffsfs_deviceList);
+}
 
-       while(cfg && cfg->prefix && cfg->dev){
-               cfg->dev->isMounted = 0;
-               cfg->dev->param.removeObjectCallback = yaffsfs_RemoveObjectCallback;
-               cfg++;
-       }
+void yaffs_RemoveDevice(yaffs_Device *dev)
+{
+       ylist_del_init(&dev->devList);
+}
 
 
-}
 
 
-//
-// Directory search stuff.
+/* Directory search stuff. */
 
-//
-// Directory search context
-//
-// NB this is an opaque structure.
+/*
+ * Directory search context
+ *
+ * NB this is an opaque structure.
+ */
 
 
 typedef struct
@@ -1737,7 +2077,7 @@ struct yaffs_dirent *yaffs_readdir(yaffs_DIR *dirp)
                        yaffs_GetObjectName(dsc->nextReturn,dsc->de.d_name,NAME_MAX);
                        if(yaffs_strnlen(dsc->de.d_name,NAME_MAX+1) == 0)
                        {
-                               // this should not happen!
+                               /* this should not happen! */
                                yaffs_strcpy(dsc->de.d_name,_Y("zz"));
                        }
                        dsc->de.d_reclen = sizeof(struct yaffs_dirent);
@@ -1779,7 +2119,7 @@ int yaffs_closedir(yaffs_DIR *dirp)
         return 0;
 }
 
-// end of directory stuff
+/* End of directory stuff */
 
 
 int yaffs_symlink(const YCHAR *oldpath, const YCHAR *newpath)
@@ -1788,7 +2128,7 @@ int yaffs_symlink(const YCHAR *oldpath, const YCHAR *newpath)
        yaffs_Object *obj;
        YCHAR *name;
        int retVal= -1;
-       int mode = 0; // ignore for now
+       int mode = 0; /* ignore for now */
 
        yaffsfs_Lock();
        parent = yaffsfs_FindDirectory(NULL,newpath,&name,0);
@@ -1799,7 +2139,7 @@ int yaffs_symlink(const YCHAR *oldpath, const YCHAR *newpath)
                if(obj)
                        retVal = 0;
                else{
-                       yaffsfs_SetError(-ENOSPC); // just assume no space for now
+                       yaffsfs_SetError(-ENOSPC); /* just assume no space for now */
                        retVal = -1;
                }
        } else {
@@ -1841,7 +2181,7 @@ int yaffs_readlink(const YCHAR *path, YCHAR *buf, int bufsiz)
 
 int yaffs_link(const YCHAR *oldpath, const YCHAR *newpath)
 {
-       // Creates a link called newpath to existing oldpath
+       /* Creates a link called newpath to existing oldpath */
        yaffs_Object *obj = NULL;
        yaffs_Object *target = NULL;
        int retVal = 0;
@@ -1909,6 +2249,23 @@ int yaffs_mknod(const YCHAR *pathname, mode_t mode, dev_t dev)
        return -1;
 }
 
+
+
+/*
+ * yaffs_n_handles()
+ * Returns number of handles attached to the object
+ */
+int yaffs_n_handles(const YCHAR *path)
+{
+       yaffs_Object *obj;
+
+       obj = yaffsfs_FindObject(NULL,path,0);
+       if(obj)
+               obj = yaffs_GetEquivalentObject(obj);
+
+       return yaffsfs_CountHandles(obj);
+}
+
 int yaffs_DumpDevStruct(const YCHAR *path)
 {
 #if 0