Fix dependencies in Kconfig
[yaffs2.git] / direct / yaffsfs.c
index 2b9d0bc..a096190 100644 (file)
@@ -10,7 +10,7 @@
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  */
+
 #include "yaffsfs.h"
 #include "yaffs_guts.h"
 #include "yaffscfg.h"
@@ -24,7 +24,7 @@
 #endif
 
 
-const char *yaffsfs_c_version="$Id: yaffsfs.c,v 1.19 2008-05-05 07:58:58 charles Exp $";
+const char *yaffsfs_c_version="$Id: yaffsfs.c,v 1.24 2008-11-11 01:47:46 charles Exp $";
 
 // configurationList is the list of devices that are supported
 static yaffsfs_DeviceConfiguration *yaffsfs_configurationList;
@@ -36,7 +36,7 @@ static void yaffsfs_RemoveObjectCallback(yaffs_Object *obj);
 
 
 // Handle management.
-// 
+//
 
 
 unsigned int yaffs_wr_attempts;
@@ -74,7 +74,7 @@ yaffsfs_Handle *yaffsfs_GetHandlePointer(int h)
        {
                return NULL;
        }
-       
+
        return &yaffsfs_handle[h];
 }
 
@@ -86,7 +86,7 @@ yaffs_Object *yaffsfs_GetHandleObject(int handle)
        {
                return h->obj;
        }
-       
+
        return NULL;
 }
 
@@ -99,7 +99,7 @@ static int yaffsfs_GetHandle(void)
 {
        int i;
        yaffsfs_Handle *h;
-       
+
        for(i = 0; i < YAFFSFS_N_HANDLES; i++)
        {
                h = yaffsfs_GetHandlePointer(i);
@@ -123,7 +123,7 @@ static int yaffsfs_GetHandle(void)
 static int yaffsfs_PutHandle(int handle)
 {
        yaffsfs_Handle *h = yaffsfs_GetHandlePointer(handle);
-       
+
        if(h)
        {
                h->inUse = 0;
@@ -146,13 +146,13 @@ int yaffsfs_Match(YCHAR a, YCHAR b)
 int yaffsfs_IsPathDivider(YCHAR ch)
 {
        YCHAR *str = YAFFS_PATH_DIVIDERS;
-       
+
        while(*str){
                if(*str == ch)
                        return 1;
                str++;
        }
-       
+
        return 0;
 }
 
@@ -169,7 +169,8 @@ static yaffs_Device *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPath)
        yaffs_Device *retval = 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.
@@ -178,48 +179,50 @@ static yaffs_Device *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPath)
                leftOver = path;
                p = cfg->prefix;
                thisMatchLength = 0;
-               
-               
-               // Strip off any leading /'s
-               
-               while(yaffsfs_IsPathDivider(*p))
-                       p++;
+               matching = 1;
+
+
+               while(matching && *p && *leftOver){
+                       // Skip over any /s
+                       while(yaffsfs_IsPathDivider(*p))
+                             p++;
+
+                       // Skip over any /s
+                       while(yaffsfs_IsPathDivider(*leftOver))
+                             leftOver++;
+
+                       // Now match the text part
+                       while(matching &&
+                             *p && !yaffsfs_IsPathDivider(*p) &&
+                             *leftOver && !yaffsfs_IsPathDivider(*leftOver)){
+                               if(yaffsfs_Match(*p,*leftOver)){
+                                       p++;
+                                       leftOver++;
+                                       thisMatchLength++;
+                               } else {
+                                       matching = 0;
+                               }
+                       }
+               }
 
+               // Skip over any /s in leftOver
                while(yaffsfs_IsPathDivider(*leftOver))
-                       leftOver++;
-                       
-               while(*p && *leftOver && 
-                     yaffsfs_Match(*p,*leftOver))
-               {
-                       p++;
-                       leftOver++;
-                       thisMatchLength++;
-                       
-                       // Skip over any multiple /'s to treat them as one or
-                       // skip over a trailling / in the prefix, but not the matching string
-                       while(yaffsfs_IsPathDivider(*p) &&
-                             (yaffsfs_IsPathDivider(*(p+1)) || !(*(p+1))))
-                             p++;                      
-
-                       // Only skip over multiple /'s
-                       while(yaffsfs_IsPathDivider(*leftOver) &&
-                             yaffsfs_IsPathDivider(*(leftOver+1)))
-                             leftOver++;                       
-               }
+                     leftOver++;
                
-               if((!*p ) &&
-                  (!*leftOver || yaffsfs_IsPathDivider(*leftOver)) && // no more in this path name part
-                  (thisMatchLength > longestMatch))
+
+               if( matching && (thisMatchLength > longestMatch))
                {
                        // Matched prefix
                        *restOfPath = (YCHAR *)leftOver;
                        retval = cfg->dev;
                        longestMatch = thisMatchLength;
                }
+
                cfg++;
        }
        return retval;
 }
+
 #if 0
 static yaffs_Device *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPath)
 {
@@ -229,7 +232,7 @@ static yaffs_Device *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPath)
        yaffs_Device *retval = NULL;
        int thisMatchLength;
        int longestMatch = -1;
-       
+
        // Check all configs, choose the one that:
        // 1) Actually matches a prefix (ie /a amd /abc will not match
        // 2) Matches the longest.
@@ -238,17 +241,17 @@ static yaffs_Device *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPath)
                leftOver = path;
                p = cfg->prefix;
                thisMatchLength = 0;
-               
-               while(*p &&  //unmatched part of prefix 
+
+               while(*p &&  //unmatched part of prefix
                      !(yaffsfs_IsPathDivider(*p) && (p[1] == 0)) && // the rest of the prefix is not / (to catch / at end)
-                     *leftOver && 
+                     *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
@@ -269,7 +272,7 @@ static yaffs_Object *yaffsfs_FindRoot(const YCHAR *path, YCHAR **restOfPath)
 {
 
        yaffs_Device *dev;
-       
+
        dev= yaffsfs_FindDevice(path,restOfPath);
        if(dev && dev->isMounted)
        {
@@ -284,7 +287,7 @@ static yaffs_Object *yaffsfs_FollowLink(yaffs_Object *obj,int symDepth)
        while(obj && obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK)
        {
                YCHAR *alias = obj->variant.symLinkVariant.alias;
-                                               
+
                if(yaffsfs_IsPathDivider(*alias))
                {
                        // Starts with a /, need to scan from root up
@@ -310,12 +313,12 @@ static yaffs_Object *yaffsfs_DoFindDirectory(yaffs_Object *startDir,const YCHAR
        YCHAR *restOfPath;
        YCHAR str[YAFFS_MAX_NAME_LENGTH+1];
        int i;
-       
+
        if(symDepth > YAFFSFS_MAX_SYMLINK_DEREFERENCES)
        {
                return NULL;
        }
-       
+
        if(startDir)
        {
                dir = startDir;
@@ -325,20 +328,20 @@ 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 '/' 
+               // 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 '/'
                }
-               
+
                *name = restOfPath;
                i = 0;
-               
+
                while(*restOfPath && !yaffsfs_IsPathDivider(*restOfPath))
                {
                        if (i < YAFFS_MAX_NAME_LENGTH)
@@ -349,7 +352,7 @@ static yaffs_Object *yaffsfs_DoFindDirectory(yaffs_Object *startDir,const YCHAR
                        }
                        restOfPath++;
                }
-               
+
                if(!*restOfPath)
                {
                        // got to the end of the string
@@ -368,14 +371,14 @@ static yaffs_Object *yaffsfs_DoFindDirectory(yaffs_Object *startDir,const YCHAR
                        else
                        {
                                dir = yaffs_FindObjectByName(dir,str);
-                               
+
                                while(dir && dir->variantType == YAFFS_OBJECT_TYPE_SYMLINK)
                                {
-                               
+
                                        dir = yaffsfs_FollowLink(dir,symDepth);
-               
+
                                }
-                               
+
                                if(dir && dir->variantType != YAFFS_OBJECT_TYPE_DIRECTORY)
                                {
                                        dir = NULL;
@@ -393,19 +396,19 @@ static yaffs_Object *yaffsfs_FindDirectory(yaffs_Object *relativeDirectory,const
 }
 
 // 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;
        YCHAR *name;
-       
+
        dir = yaffsfs_FindDirectory(relativeDirectory,path,&name,symDepth);
-       
+
        if(dir && *name)
        {
                return yaffs_FindObjectByName(dir,name);
        }
-       
+
        return dir;
 }
 
@@ -415,27 +418,27 @@ int yaffs_dup(int fd)
        int newHandle = -1;
        yaffsfs_Handle *oldPtr = NULL;
        yaffsfs_Handle *newPtr = NULL;
-       
+
        yaffsfs_Lock();
-       
+
        oldPtr = yaffsfs_GetHandlePointer(fd);
        if(oldPtr && oldPtr->inUse)
                newHandle = yaffsfs_GetHandle();
        if(newHandle >= 0)
                newPtr = yaffsfs_GetHandlePointer(newHandle);
-               
+
        if(newPtr){
                *newPtr = *oldPtr;
                return newHandle;
        }
-       
+
        if(!oldPtr)
                yaffsfs_SetError(-EBADF);
        else
                yaffsfs_SetError(-ENOMEM);
-       
+
        return -1;
-               
+
 }
 
 int yaffs_open(const YCHAR *path, int oflag, int mode)
@@ -450,29 +453,29 @@ int yaffs_open(const YCHAR *path, int oflag, int mode)
        int openDenied = 0;
        int symDepth = 0;
        int errorReported = 0;
-       
+
        int i;
-       
-       
+
+
        // todo sanity check oflag (eg. can't have O_TRUNC without WRONLY or RDWR
-       
-       
+
+
        yaffsfs_Lock();
-       
+
        handle = yaffsfs_GetHandle();
-       
+
        if(handle >= 0)
        {
 
                h = yaffsfs_GetHandlePointer(handle);
-       
-       
+
+
                // try to find the exisiting object
                obj = yaffsfs_FindObject(NULL,path,0);
-               
+
                if(obj && obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK)
                {
-               
+
                        obj = yaffsfs_FollowLink(obj,symDepth++);
                }
 
@@ -485,10 +488,10 @@ int yaffs_open(const YCHAR *path, int oflag, int mode)
                {
                        // Check if the object is already in use
                        alreadyOpen = alreadyExclusive = 0;
-                       
-                       for(i = 0; i <= YAFFSFS_N_HANDLES; i++)
+
+                       for(i = 0; i < YAFFSFS_N_HANDLES; i++)
                        {
-                               
+
                                if(i != handle &&
                                   yaffsfs_handle[i].inUse &&
                                    obj == yaffsfs_handle[i].obj)
@@ -505,7 +508,7 @@ int yaffs_open(const YCHAR *path, int oflag, int mode)
                        {
                                openDenied = 1;
                        }
-                       
+
                        // Open should fail if O_CREAT and O_EXCL are specified
                        if((oflag & O_EXCL) && (oflag & O_CREAT))
                        {
@@ -513,7 +516,7 @@ int yaffs_open(const YCHAR *path, int oflag, int mode)
                                yaffsfs_SetError(-EEXIST);
                                errorReported = 1;
                        }
-                       
+
                        // Check file permissions
                        if( (oflag & (O_RDWR | O_WRONLY)) == 0 &&     // ie O_RDONLY
                           !(obj->yst_mode & S_IREAD))
@@ -521,27 +524,27 @@ int yaffs_open(const YCHAR *path, int oflag, int mode)
                                openDenied = 1;
                        }
 
-                       if( (oflag & O_RDWR) && 
+                       if( (oflag & O_RDWR) &&
                           !(obj->yst_mode & S_IREAD))
                        {
                                openDenied = 1;
                        }
 
-                       if( (oflag & (O_RDWR | O_WRONLY)) && 
+                       if( (oflag & (O_RDWR | O_WRONLY)) &&
                           !(obj->yst_mode & S_IWRITE))
                        {
                                openDenied = 1;
                        }
-                       
+
                }
-               
+
                else if((oflag & O_CREAT))
                {
                        // Let's see if we can create this file
                        dir = yaffsfs_FindDirectory(NULL,path,&name,0);
                        if(dir)
                        {
-                               obj = yaffs_MknodFile(dir,name,mode,0,0);       
+                               obj = yaffs_MknodFile(dir,name,mode,0,0);
                        }
                        else
                        {
@@ -549,7 +552,7 @@ int yaffs_open(const YCHAR *path, int oflag, int mode)
                                errorReported = 1;
                        }
                }
-               
+
                if(obj && !openDenied)
                {
                        h->obj = obj;
@@ -558,14 +561,13 @@ int yaffs_open(const YCHAR *path, int oflag, int mode)
                        h->append =  (oflag & O_APPEND) ? 1 : 0;
                        h->exclusive = (oflag & O_EXCL) ? 1 : 0;
                        h->position = 0;
-                       
-                       obj->inUse++;
-                       if((oflag & O_TRUNC) && !h->readOnly)
-                       {
-                               //todo truncate
-                               yaffs_ResizeFile(obj,0);
-                       }
-                       
+
+                        obj->inUse++;
+                        if((oflag & O_TRUNC) && !h->readOnly)
+                        {
+                                yaffs_ResizeFile(obj,0);
+                        }
+
                }
                else
                {
@@ -605,21 +607,22 @@ int yaffs_flush(int fd)
                yaffsfs_SetError(-EBADF);
                retVal = -1;
        }
-       
+
        yaffsfs_Unlock();
 
        return retVal;
 }
 
+
 int yaffs_close(int fd)
 {
        yaffsfs_Handle *h = NULL;
        int retVal = 0;
-       
+
        yaffsfs_Lock();
 
        h = yaffsfs_GetHandlePointer(fd);
-       
+
        if(h && h->inUse)
        {
                // clean up
@@ -635,12 +638,12 @@ int yaffs_close(int fd)
        else
        {
                // bad handle
-               yaffsfs_SetError(-EBADF);               
+               yaffsfs_SetError(-EBADF);
                retVal = -1;
        }
-       
+
        yaffsfs_Unlock();
-       
+
        return retVal;
 }
 
@@ -651,15 +654,15 @@ int yaffs_read(int fd, void *buf, unsigned int nbyte)
        int pos = 0;
        int nRead = -1;
        unsigned int maxRead;
-       
+
        yaffsfs_Lock();
        h = yaffsfs_GetHandlePointer(fd);
        obj = yaffsfs_GetHandleObject(fd);
-       
+
        if(!h || !obj)
        {
                // bad handle
-               yaffsfs_SetError(-EBADF);               
+               yaffsfs_SetError(-EBADF);
        }
        else if( h && obj)
        {
@@ -678,7 +681,7 @@ int yaffs_read(int fd, void *buf, unsigned int nbyte)
                        nbyte = maxRead;
                }
 
-               
+
                if(nbyte > 0)
                {
                        nRead = yaffs_ReadDataFromFile(obj,buf,pos,nbyte);
@@ -695,14 +698,14 @@ int yaffs_read(int fd, void *buf, unsigned int nbyte)
                {
                        nRead = 0;
                }
-               
+
        }
-       
+
        yaffsfs_Unlock();
-       
-       
+
+
        return (nRead >= 0) ? nRead : -1;
-               
+
 }
 
 int yaffs_pread(int fd, void *buf, unsigned int nbyte, unsigned int offset)
@@ -712,15 +715,15 @@ int yaffs_pread(int fd, void *buf, unsigned int nbyte, unsigned int offset)
        int pos = 0;
        int nRead = -1;
        unsigned int maxRead;
-       
+
        yaffsfs_Lock();
        h = yaffsfs_GetHandlePointer(fd);
        obj = yaffsfs_GetHandleObject(fd);
-       
+
        if(!h || !obj)
        {
                // bad handle
-               yaffsfs_SetError(-EBADF);               
+               yaffsfs_SetError(-EBADF);
        }
        else if( h && obj)
        {
@@ -739,7 +742,7 @@ int yaffs_pread(int fd, void *buf, unsigned int nbyte, unsigned int offset)
                        nbyte = maxRead;
                }
 
-               
+
                if(nbyte > 0)
                {
                        nRead = yaffs_ReadDataFromFile(obj,buf,pos,nbyte);
@@ -748,14 +751,14 @@ int yaffs_pread(int fd, void *buf, unsigned int nbyte, unsigned int offset)
                {
                        nRead = 0;
                }
-               
+
        }
-       
+
        yaffsfs_Unlock();
-       
-       
+
+
        return (nRead >= 0) ? nRead : -1;
-               
+
 }
 
 int yaffs_write(int fd, const void *buf, unsigned int nbyte)
@@ -765,15 +768,15 @@ int yaffs_write(int fd, const void *buf, unsigned int nbyte)
        int pos = 0;
        int nWritten = -1;
        int writeThrough = 0;
-       
+
        yaffsfs_Lock();
        h = yaffsfs_GetHandlePointer(fd);
        obj = yaffsfs_GetHandleObject(fd);
-       
+
        if(!h || !obj)
        {
                // bad handle
-               yaffsfs_SetError(-EBADF);               
+               yaffsfs_SetError(-EBADF);
        }
        else if( h && obj && h->readOnly)
        {
@@ -789,9 +792,9 @@ int yaffs_write(int fd, const void *buf, unsigned int nbyte)
                {
                        pos = h->position;
                }
-               
+
                nWritten = yaffs_WriteDataToFile(obj,buf,pos,nbyte,writeThrough);
-               
+
                if(nWritten >= 0)
                {
                        h->position = pos + nWritten;
@@ -800,12 +803,12 @@ int yaffs_write(int fd, const void *buf, unsigned int nbyte)
                {
                        //todo error
                }
-               
+
        }
-       
+
        yaffsfs_Unlock();
-       
-       
+
+
        return (nWritten >= 0) ? nWritten : -1;
 
 }
@@ -817,15 +820,15 @@ int yaffs_pwrite(int fd, const void *buf, unsigned int nbyte, unsigned int offse
        int pos = 0;
        int nWritten = -1;
        int writeThrough = 0;
-       
+
        yaffsfs_Lock();
        h = yaffsfs_GetHandlePointer(fd);
        obj = yaffsfs_GetHandleObject(fd);
-       
+
        if(!h || !obj)
        {
                // bad handle
-               yaffsfs_SetError(-EBADF);               
+               yaffsfs_SetError(-EBADF);
        }
        else if( h && obj && h->readOnly)
        {
@@ -834,27 +837,27 @@ int yaffs_pwrite(int fd, const void *buf, unsigned int nbyte, unsigned int offse
        else if( h && obj)
        {
                pos = offset;
-                               
-               nWritten = yaffs_WriteDataToFile(obj,buf,pos,nbyte,writeThrough);
-               
-               if(nWritten < nbyte)
-                       yaffsfs_SetError(-ENOSPC);
-               
-       }
-       
+
+                nWritten = yaffs_WriteDataToFile(obj,buf,pos,nbyte,writeThrough);
+
+                if(nWritten < 0 || ((unsigned int)nWritten) < nbyte)
+                        yaffsfs_SetError(-ENOSPC);
+
+        }
+
        yaffsfs_Unlock();
-       
-       
+
+
        return (nWritten >= 0) ? nWritten : -1;
 
 }
 
 
-int yaffs_truncate(const YCHAR *path,off_t newSize) 
+int yaffs_truncate(const YCHAR *path,off_t newSize)
 {
        yaffs_Object *obj = NULL;
        int result = YAFFS_FAIL;
-       
+
        yaffsfs_Lock();
 
        obj = yaffsfs_FindObject(NULL,path,0);
@@ -873,10 +876,10 @@ int yaffs_truncate(const YCHAR *path,off_t newSize)
        {
                result = yaffs_ResizeFile(obj,newSize);
        }
-       
+
        yaffsfs_Unlock();
-       
-       
+
+
        return (result) ? 0 : -1;
 }
 
@@ -885,43 +888,43 @@ int yaffs_ftruncate(int fd, off_t newSize)
        yaffsfs_Handle *h = NULL;
        yaffs_Object *obj = NULL;
        int result = 0;
-       
+
        yaffsfs_Lock();
        h = yaffsfs_GetHandlePointer(fd);
        obj = yaffsfs_GetHandleObject(fd);
-       
+
        if(!h || !obj)
        {
                // bad handle
-               yaffsfs_SetError(-EBADF);               
+               yaffsfs_SetError(-EBADF);
        }
        else
        {
                // resize the file
                result = yaffs_ResizeFile(obj,newSize);
-       }       
+       }
        yaffsfs_Unlock();
-       
-       
+
+
        return (result) ? 0 : -1;
 
 }
 
-off_t yaffs_lseek(int fd, off_t offset, int whence) 
+off_t yaffs_lseek(int fd, off_t offset, int whence)
 {
        yaffsfs_Handle *h = NULL;
        yaffs_Object *obj = NULL;
        int pos = -1;
        int fSize = -1;
-       
+
        yaffsfs_Lock();
        h = yaffsfs_GetHandlePointer(fd);
        obj = yaffsfs_GetHandleObject(fd);
-       
+
        if(!h || !obj)
        {
                // bad handle
-               yaffsfs_SetError(-EBADF);               
+               yaffsfs_SetError(-EBADF);
        }
        else if(whence == SEEK_SET)
        {
@@ -945,7 +948,7 @@ off_t yaffs_lseek(int fd, off_t offset, int whence)
                        pos = fSize + offset;
                }
        }
-       
+
        if(pos >= 0)
        {
                h->position = pos;
@@ -955,20 +958,20 @@ off_t yaffs_lseek(int fd, off_t offset, int whence)
                // todo error
        }
 
-       
+
        yaffsfs_Unlock();
-       
+
        return pos;
 }
 
 
-int yaffsfs_DoUnlink(const YCHAR *path,int isDirectory) 
+int yaffsfs_DoUnlink(const YCHAR *path,int isDirectory)
 {
        yaffs_Object *dir = NULL;
        yaffs_Object *obj = NULL;
        YCHAR *name;
        int result = YAFFS_FAIL;
-       
+
        yaffsfs_Lock();
 
        obj = yaffsfs_FindObject(NULL,path,0);
@@ -992,27 +995,27 @@ int yaffsfs_DoUnlink(const YCHAR *path,int isDirectory)
        else
        {
                result = yaffs_Unlink(dir,name);
-               
+
                if(result == YAFFS_FAIL && isDirectory)
                {
                        yaffsfs_SetError(-ENOTEMPTY);
                }
        }
-       
+
        yaffsfs_Unlock();
-       
+
        // todo error
-       
+
        return (result == YAFFS_FAIL) ? -1 : 0;
 }
 
 
-int yaffs_rmdir(const YCHAR *path) 
+int yaffs_rmdir(const YCHAR *path)
 {
        return yaffsfs_DoUnlink(path,1);
 }
 
-int yaffs_unlink(const YCHAR *path) 
+int yaffs_unlink(const YCHAR *path)
 {
        return yaffsfs_DoUnlink(path,0);
 }
@@ -1026,34 +1029,34 @@ int yaffs_rename(const YCHAR *oldPath, const YCHAR *newPath)
        YCHAR *newname;
        int result= YAFFS_FAIL;
        int renameAllowed = 1;
-       
+
        yaffsfs_Lock();
-       
+
        olddir = yaffsfs_FindDirectory(NULL,oldPath,&oldname,0);
        newdir = yaffsfs_FindDirectory(NULL,newPath,&newname,0);
        obj = yaffsfs_FindObject(NULL,oldPath,0);
-       
+
        if(!olddir || !newdir || !obj)
        {
                // bad file
-               yaffsfs_SetError(-EBADF);       
-               renameAllowed = 0;      
+               yaffsfs_SetError(-EBADF);
+               renameAllowed = 0;
        }
        else if(olddir->myDev != newdir->myDev)
        {
                // oops must be on same device
                // todo error
                yaffsfs_SetError(-EXDEV);
-               renameAllowed = 0;      
+               renameAllowed = 0;
        }
        else if(obj && obj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY)
        {
-               // It is a directory, check that it is not being renamed to 
+               // 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;
-               
+
                while( renameAllowed && xx)
                {
                        if(xx == obj)
@@ -1064,15 +1067,15 @@ int yaffs_rename(const YCHAR *oldPath, const YCHAR *newPath)
                }
                if(!renameAllowed) yaffsfs_SetError(-EACCES);
        }
-       
+
        if(renameAllowed)
        {
                result = yaffs_RenameObject(olddir,oldname,newdir,newname);
        }
-       
+
        yaffsfs_Unlock();
-       
-       return (result == YAFFS_FAIL) ? -1 : 0; 
+
+       return (result == YAFFS_FAIL) ? -1 : 0;
 }
 
 
@@ -1090,12 +1093,12 @@ static int yaffsfs_DoStat(yaffs_Object *obj,struct yaffs_stat *buf)
        buf->st_dev = (int)obj->myDev->genericDevice;
        buf->st_ino = obj->objectId;
        buf->st_mode = obj->yst_mode & ~S_IFMT; // clear out file type bits
-       
-               if(obj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY) 
+
+               if(obj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY)
                {
                        buf->st_mode |= S_IFDIR;
                }
-               else if(obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK) 
+               else if(obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK)
                {
                        buf->st_mode |= S_IFLNK;
                }
@@ -1103,10 +1106,10 @@ static int yaffsfs_DoStat(yaffs_Object *obj,struct yaffs_stat *buf)
                {
                        buf->st_mode |= S_IFREG;
                }
-               
+
        buf->st_nlink = yaffs_GetObjectLinkCount(obj);
-       buf->st_uid = 0;    
-       buf->st_gid = 0;;     
+       buf->st_uid = 0;
+       buf->st_gid = 0;;
        buf->st_rdev = obj->yst_rdev;
        buf->st_size = yaffs_GetObjectFileLength(obj);
                buf->st_blksize = obj->myDev->nDataBytesPerChunk;
@@ -1131,17 +1134,17 @@ static int yaffsfs_DoStat(yaffs_Object *obj,struct yaffs_stat *buf)
 static int yaffsfs_DoStatOrLStat(const YCHAR *path, struct yaffs_stat *buf,int doLStat)
 {
        yaffs_Object *obj;
-       
+
        int retVal = -1;
-       
+
        yaffsfs_Lock();
        obj = yaffsfs_FindObject(NULL,path,0);
-       
+
        if(!doLStat && obj)
        {
                obj = yaffsfs_FollowLink(obj,0);
        }
-       
+
        if(obj)
        {
                retVal = yaffsfs_DoStat(obj,buf);
@@ -1151,11 +1154,11 @@ static int yaffsfs_DoStatOrLStat(const YCHAR *path, struct yaffs_stat *buf,int d
                // todo error not found
                yaffsfs_SetError(-ENOENT);
        }
-       
+
        yaffsfs_Unlock();
-       
+
        return retVal;
-       
+
 }
 
 int yaffs_stat(const YCHAR *path, struct yaffs_stat *buf)
@@ -1171,12 +1174,12 @@ int yaffs_lstat(const YCHAR *path, struct yaffs_stat *buf)
 int yaffs_fstat(int fd, struct yaffs_stat *buf)
 {
        yaffs_Object *obj;
-       
+
        int retVal = -1;
-       
+
        yaffsfs_Lock();
        obj = yaffsfs_GetHandleObject(fd);
-       
+
        if(obj)
        {
                retVal = yaffsfs_DoStat(obj,buf);
@@ -1236,13 +1239,13 @@ int yaffs_get_wince_times(int fd, unsigned *wctime, unsigned *watime, unsigned *
 int yaffs_set_wince_times(int fd, 
                                                  const unsigned *wctime, 
                                                  const unsigned *watime, 
-                                                 const unsigned *wmtime)
+                                                  const unsigned *wmtime)
 {
-       yaffs_Object *obj;
-       
-       int retVal = -1;
+        yaffs_Object *obj;
+        int result;
+        int retVal = -1;
 
-       yaffsfs_Lock();
+        yaffsfs_Lock();
        obj = yaffsfs_GetHandleObject(fd);
 
        if(obj)
@@ -1253,17 +1256,19 @@ int yaffs_set_wince_times(int fd,
                        obj->win_ctime[1] = wctime[1];
                }
                if(watime){
-                       obj->win_atime[0] = watime[0];
-                       obj->win_atime[1] = watime[1];
-               }
-               if(wctime){
-                       obj->win_mtime[0] = wmtime[0];
-                       obj->win_mtime[1] = wmtime[1];
-               }
-
-               retVal = 0;
-       }
-       else
+                        obj->win_atime[0] = watime[0];
+                        obj->win_atime[1] = watime[1];
+                }
+                if(wmtime){
+                        obj->win_mtime[0] = wmtime[0];
+                        obj->win_mtime[1] = wmtime[1];
+                }
+
+                obj->dirty = 1;
+                result = yaffs_FlushFile(obj,0);
+                retVal = 0;
+        }
+        else
        {
                // bad handle
                yaffsfs_SetError(-EBADF);
@@ -1279,20 +1284,20 @@ int yaffs_set_wince_times(int fd,
 
 static int yaffsfs_DoChMod(yaffs_Object *obj,mode_t mode)
 {
-       int result;
+       int result = -1;
 
        if(obj)
        {
                obj = yaffs_GetEquivalentObject(obj);
        }
-       
+
        if(obj)
        {
                obj->yst_mode = mode;
                obj->dirty = 1;
                result = yaffs_FlushFile(obj,0);
        }
-       
+
        return result == YAFFS_OK ? 0 : -1;
 }
 
@@ -1300,16 +1305,16 @@ static int yaffsfs_DoChMod(yaffs_Object *obj,mode_t mode)
 int yaffs_access(const YCHAR *path, int amode)
 {
        yaffs_Object *obj;
-       
+
        int retval = 0;
-       
+
        yaffsfs_Lock();
        obj = yaffsfs_FindObject(NULL,path,0);
-       
+
        if(obj)
        {
                int access_ok = 1;
-               
+
                if((amode & R_OK) && !(obj->yst_mode & S_IREAD))
                        access_ok = 0;
                if((amode & W_OK) && !(obj->yst_mode & S_IWRITE))
@@ -1328,23 +1333,23 @@ int yaffs_access(const YCHAR *path, int amode)
                yaffsfs_SetError(-ENOENT);
                retval = -1;
        }
-       
+
        yaffsfs_Unlock();
-       
+
        return retval;
-       
+
 }
 
 
 int yaffs_chmod(const YCHAR *path, mode_t mode)
 {
        yaffs_Object *obj;
-       
+
        int retVal = -1;
-       
+
        yaffsfs_Lock();
        obj = yaffsfs_FindObject(NULL,path,0);
-       
+
        if(obj)
        {
                retVal = yaffsfs_DoChMod(obj,mode);
@@ -1354,23 +1359,23 @@ int yaffs_chmod(const YCHAR *path, mode_t mode)
                // todo error not found
                yaffsfs_SetError(-ENOENT);
        }
-       
+
        yaffsfs_Unlock();
-       
+
        return retVal;
-       
+
 }
 
 
 int yaffs_fchmod(int fd, mode_t mode)
 {
        yaffs_Object *obj;
-       
+
        int retVal = -1;
-       
+
        yaffsfs_Lock();
        obj = yaffsfs_GetHandleObject(fd);
-       
+
        if(obj)
        {
                retVal = yaffsfs_DoChMod(obj,mode);
@@ -1378,11 +1383,11 @@ int yaffs_fchmod(int fd, mode_t mode)
        else
        {
                // bad handle
-               yaffsfs_SetError(-EBADF);               
+               yaffsfs_SetError(-EBADF);
        }
-       
+
        yaffsfs_Unlock();
-       
+
        return retVal;
 }
 
@@ -1393,7 +1398,7 @@ int yaffs_mkdir(const YCHAR *path, mode_t mode)
        yaffs_Object *dir = NULL;
        YCHAR *name;
        int retVal= -1;
-       
+
        yaffsfs_Lock();
        parent = yaffsfs_FindDirectory(NULL,path,&name,0);
        if(parent)
@@ -1411,12 +1416,12 @@ int yaffs_mkdir(const YCHAR *path, mode_t mode)
                        yaffsfs_SetError(-EEXIST); // the name already exists
                }
                else
-                       yaffsfs_SetError(-ENOSPC); // just assume no space 
+                       yaffsfs_SetError(-ENOSPC); // just assume no space
                retVal = -1;
        }
-       
+
        yaffsfs_Unlock();
-       
+
        return retVal;
 }
 
@@ -1426,9 +1431,9 @@ int yaffs_mount(const YCHAR *path)
        int result=YAFFS_FAIL;
        yaffs_Device *dev=NULL;
        YCHAR *dummy;
-       
+
        T(YAFFS_TRACE_ALWAYS,(TSTR("yaffs: Mounting %s" TENDSTR),path));
-       
+
        yaffsfs_Lock();
        dev = yaffsfs_FindDevice(path,&dummy);
        if(dev)
@@ -1442,7 +1447,7 @@ int yaffs_mount(const YCHAR *path)
                                yaffsfs_SetError(-ENOMEM);
                        }
                        retVal = result ? 0 : -1;
-                       
+
                }
                else
                {
@@ -1457,50 +1462,50 @@ int yaffs_mount(const YCHAR *path)
        }
        yaffsfs_Unlock();
        return retVal;
-       
+
 }
 
 int yaffs_sync(const YCHAR *path)
 {
-       int retVal=-1;
-       yaffs_Device *dev=NULL;
-       YCHAR *dummy;
-       
-       yaffsfs_Lock();
-       dev = yaffsfs_FindDevice(path,&dummy);
-       if(dev)
-       {
-               if(dev->isMounted)
-               {
-                       
-                       yaffs_FlushEntireDeviceCache(dev);
-                       yaffs_CheckpointSave(dev);
-                       
-                       
-               }
-               else
-               {
-                       //todo error - not mounted.
-                       yaffsfs_SetError(-EINVAL);
-                       
-               }
-       }
-       else
-       {
-               // todo error - no device
-               yaffsfs_SetError(-ENODEV);
-       }       
-       yaffsfs_Unlock();
-       return retVal;  
+        int retVal=-1;
+        yaffs_Device *dev=NULL;
+        YCHAR *dummy;
+        
+        yaffsfs_Lock();
+        dev = yaffsfs_FindDevice(path,&dummy);
+        if(dev)
+        {
+                if(dev->isMounted)
+                {
+                        
+                        yaffs_FlushEntireDeviceCache(dev);
+                        yaffs_CheckpointSave(dev);
+                        
+                        
+                }
+                else
+                {
+                        //todo error - not mounted.
+                        yaffsfs_SetError(-EINVAL);
+                        
+                }
+        }
+        else
+        {
+                // todo error - no device
+                yaffsfs_SetError(-ENODEV);
+        }       
+        yaffsfs_Unlock();
+        return retVal;  
 }
 
 
 int yaffs_unmount(const YCHAR *path)
 {
-       int retVal=-1;
+        int retVal=-1;
        yaffs_Device *dev=NULL;
        YCHAR *dummy;
-       
+
        yaffsfs_Lock();
        dev = yaffsfs_FindDevice(path,&dummy);
        if(dev)
@@ -1509,10 +1514,10 @@ int yaffs_unmount(const YCHAR *path)
                {
                        int i;
                        int inUse;
-                       
+
                        yaffs_FlushEntireDeviceCache(dev);
                        yaffs_CheckpointSave(dev);
-                       
+
                        for(i = inUse = 0; i < YAFFSFS_N_HANDLES && !inUse; i++)
                        {
                                if(yaffsfs_handle[i].inUse && yaffsfs_handle[i].obj->myDev == dev)
@@ -1520,11 +1525,11 @@ int yaffs_unmount(const YCHAR *path)
                                        inUse = 1; // the device is in use, can't unmount
                                }
                        }
-                       
+
                        if(!inUse)
                        {
                                yaffs_Deinitialise(dev);
-                                       
+
                                retVal = 0;
                        }
                        else
@@ -1532,23 +1537,23 @@ int yaffs_unmount(const YCHAR *path)
                                // todo error can't unmount as files are open
                                yaffsfs_SetError(-EBUSY);
                        }
-                       
+
                }
                else
                {
                        //todo error - not mounted.
                        yaffsfs_SetError(-EINVAL);
-                       
+
                }
        }
        else
        {
                // todo error - no device
                yaffsfs_SetError(-ENODEV);
-       }       
+       }
        yaffsfs_Unlock();
        return retVal;
-       
+
 }
 
 loff_t yaffs_freespace(const YCHAR *path)
@@ -1556,7 +1561,7 @@ loff_t yaffs_freespace(const YCHAR *path)
        loff_t retVal=-1;
        yaffs_Device *dev=NULL;
        YCHAR *dummy;
-       
+
        yaffsfs_Lock();
        dev = yaffsfs_FindDevice(path,&dummy);
        if(dev  && dev->isMounted)
@@ -1593,6 +1598,28 @@ loff_t yaffs_totalspace(const YCHAR *path)
        {
                yaffsfs_SetError(-EINVAL);
        }
+
+       yaffsfs_Unlock();
+       return retVal;
+}
+
+int yaffs_inodecount(const YCHAR *path)
+{
+       loff_t retVal= -1;
+       yaffs_Device *dev=NULL;
+       YCHAR *dummy;
+
+       yaffsfs_Lock();
+       dev = yaffsfs_FindDevice(path,&dummy);
+       if(dev  && dev->isMounted) {
+          int nObjects = dev->nObjectsCreated - dev->nFreeObjects;
+          if(nObjects > dev->nHardLinks)
+               retVal = nObjects - dev->nHardLinks;
+       }
+       
+       if(retVal < 0){
+               yaffsfs_SetError(-EINVAL);
+       }
        
        yaffsfs_Unlock();
        return retVal;  
@@ -1602,23 +1629,23 @@ loff_t yaffs_totalspace(const YCHAR *path)
 
 void yaffs_initialise(yaffsfs_DeviceConfiguration *cfgList)
 {
-       
+
        yaffsfs_DeviceConfiguration *cfg;
-       
+
        yaffsfs_configurationList = cfgList;
-       
+
        yaffsfs_InitHandles();
-       
+
        cfg = yaffsfs_configurationList;
-       
+
        while(cfg && cfg->prefix && cfg->dev)
        {
                cfg->dev->isMounted = 0;
                cfg->dev->removeObjectCallback = yaffsfs_RemoveObjectCallback;
                cfg++;
        }
-       
-       
+
+
 }
 
 
@@ -1636,10 +1663,10 @@ typedef struct
        __u32 magic;
        yaffs_dirent de;                /* directory entry being used by this dsc */
        YCHAR name[NAME_MAX+1];         /* name of directory being searched */
-       yaffs_Object *dirObj;           /* ptr to directory being searched */
-       yaffs_Object *nextReturn;       /* obj to be returned by next readddir */
-       int offset;
-       struct ylist_head others;       
+        yaffs_Object *dirObj;           /* ptr to directory being searched */
+        yaffs_Object *nextReturn;       /* obj to be returned by next readddir */
+        int offset;
+        struct ylist_head others;       
 } yaffsfs_DirectorySearchContext;
 
 
@@ -1652,16 +1679,16 @@ static void yaffsfs_SetDirRewound(yaffsfs_DirectorySearchContext *dsc)
        if(dsc &&
           dsc->dirObj &&
           dsc->dirObj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY){
-          
-          dsc->offset = 0;
-          
-          if( ylist_empty(&dsc->dirObj->variant.directoryVariant.children)){
-               dsc->nextReturn = NULL;
-          } else {
-               dsc->nextReturn = ylist_entry(dsc->dirObj->variant.directoryVariant.children.next,
-                                               yaffs_Object,siblings);
-          }
-       } else {
+
+           dsc->offset = 0;
+
+           if( ylist_empty(&dsc->dirObj->variant.directoryVariant.children)){
+                dsc->nextReturn = NULL;
+           } else {
+                dsc->nextReturn = ylist_entry(dsc->dirObj->variant.directoryVariant.children.next,
+                                                yaffs_Object,siblings);
+           }
+        } else {
                /* Hey someone isn't playing nice! */
        }
 }
@@ -1670,46 +1697,46 @@ static void yaffsfs_DirAdvance(yaffsfs_DirectorySearchContext *dsc)
 {
        if(dsc &&
           dsc->dirObj &&
-          dsc->dirObj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY){
-          
-          if( dsc->nextReturn == NULL ||
-              ylist_empty(&dsc->dirObj->variant.directoryVariant.children)){
-               dsc->nextReturn = NULL;
-          } else {
-                  struct ylist_head *next = dsc->nextReturn->siblings.next;
-   
-                  if( next == &dsc->dirObj->variant.directoryVariant.children)
-                       dsc->nextReturn = NULL; /* end of list */
-                  else 
-                       dsc->nextReturn = ylist_entry(next,yaffs_Object,siblings);
-          }
-       } else {
-               /* Hey someone isn't playing nice! */
+           dsc->dirObj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY){
+
+           if( dsc->nextReturn == NULL ||
+               ylist_empty(&dsc->dirObj->variant.directoryVariant.children)){
+                dsc->nextReturn = NULL;
+           } else {
+                   struct ylist_head *next = dsc->nextReturn->siblings.next;
+
+                   if( next == &dsc->dirObj->variant.directoryVariant.children)
+                        dsc->nextReturn = NULL; /* end of list */
+                   else
+                        dsc->nextReturn = ylist_entry(next,yaffs_Object,siblings);
+           }
+        } else {
+                /* Hey someone isn't playing nice! */
        }
 }
 
 static void yaffsfs_RemoveObjectCallback(yaffs_Object *obj)
 {
 
-       struct ylist_head *i;
-       yaffsfs_DirectorySearchContext *dsc;
-       
-       /* if search contexts not initilised then skip */
-       if(!search_contexts.next)
-               return;
-               
-       /* Iterate through the directory search contexts.
-        * If any are the one being removed, then advance the dsc to
-        * the next one to prevent a hanging ptr.
-        */
-        ylist_for_each(i, &search_contexts) {
-               if (i) {
-                       dsc = ylist_entry(i, yaffsfs_DirectorySearchContext,others);
-                       if(dsc->nextReturn == obj)
-                               yaffsfs_DirAdvance(dsc);
-               }
+        struct ylist_head *i;
+        yaffsfs_DirectorySearchContext *dsc;
+
+        /* if search contexts not initilised then skip */
+        if(!search_contexts.next)
+                return;
+
+        /* Iterate through the directory search contexts.
+         * If any are the one being removed, then advance the dsc to
+         * the next one to prevent a hanging ptr.
+         */
+         ylist_for_each(i, &search_contexts) {
+                if (i) {
+                        dsc = ylist_entry(i, yaffsfs_DirectorySearchContext,others);
+                        if(dsc->nextReturn == obj)
+                                yaffsfs_DirAdvance(dsc);
+                }
        }
-                               
+
 }
 
 yaffs_DIR *yaffs_opendir(const YCHAR *dirname)
@@ -1717,34 +1744,34 @@ yaffs_DIR *yaffs_opendir(const YCHAR *dirname)
        yaffs_DIR *dir = NULL;
        yaffs_Object *obj = NULL;
        yaffsfs_DirectorySearchContext *dsc = NULL;
-       
+
        yaffsfs_Lock();
-       
+
        obj = yaffsfs_FindObject(NULL,dirname,0);
-       
+
        if(obj && obj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY)
        {
-               
+
                dsc = YMALLOC(sizeof(yaffsfs_DirectorySearchContext));
                dir = (yaffs_DIR *)dsc;
                if(dsc)
                {
                        memset(dsc,0,sizeof(yaffsfs_DirectorySearchContext));
-                       dsc->magic = YAFFS_MAGIC;
-                       dsc->dirObj = obj;
-                       yaffs_strncpy(dsc->name,dirname,NAME_MAX);
-                       YINIT_LIST_HEAD(&dsc->others);
-                       
-                       if(!search_contexts.next)
-                               YINIT_LIST_HEAD(&search_contexts);
-                               
-                       ylist_add(&dsc->others,&search_contexts);       
-                       yaffsfs_SetDirRewound(dsc);             }
-       
-       }
-       
+                        dsc->magic = YAFFS_MAGIC;
+                        dsc->dirObj = obj;
+                        yaffs_strncpy(dsc->name,dirname,NAME_MAX);
+                        YINIT_LIST_HEAD(&dsc->others);
+
+                        if(!search_contexts.next)
+                                YINIT_LIST_HEAD(&search_contexts);
+
+                        ylist_add(&dsc->others,&search_contexts);       
+                        yaffsfs_SetDirRewound(dsc);             }
+
+        }
+
        yaffsfs_Unlock();
-       
+
        return dir;
 }
 
@@ -1752,9 +1779,9 @@ struct yaffs_dirent *yaffs_readdir(yaffs_DIR *dirp)
 {
        yaffsfs_DirectorySearchContext *dsc = (yaffsfs_DirectorySearchContext *)dirp;
        struct yaffs_dirent *retVal = NULL;
-               
+
        yaffsfs_Lock();
-       
+
        if(dsc && dsc->magic == YAFFS_MAGIC){
                yaffsfs_SetError(0);
                if(dsc->nextReturn){
@@ -1777,20 +1804,20 @@ struct yaffs_dirent *yaffs_readdir(yaffs_DIR *dirp)
        {
                yaffsfs_SetError(-EBADF);
        }
-       
+
        yaffsfs_Unlock();
-       
+
        return retVal;
-       
+
 }
 
 
 void yaffs_rewinddir(yaffs_DIR *dirp)
 {
        yaffsfs_DirectorySearchContext *dsc = (yaffsfs_DirectorySearchContext *)dirp;
-       
+
        yaffsfs_Lock();
-       
+
        yaffsfs_SetDirRewound(dsc);
 
        yaffsfs_Unlock();
@@ -1800,13 +1827,13 @@ void yaffs_rewinddir(yaffs_DIR *dirp)
 int yaffs_closedir(yaffs_DIR *dirp)
 {
        yaffsfs_DirectorySearchContext *dsc = (yaffsfs_DirectorySearchContext *)dirp;
-               
-       yaffsfs_Lock();
-       dsc->magic = 0;
-       ylist_del(&dsc->others); /* unhook from list */
-       YFREE(dsc);
-       yaffsfs_Unlock();
-       return 0;
+
+        yaffsfs_Lock();
+        dsc->magic = 0;
+        ylist_del(&dsc->others); /* unhook from list */
+        YFREE(dsc);
+        yaffsfs_Unlock();
+        return 0;
 }
 
 // end of directory stuff
@@ -1819,7 +1846,7 @@ int yaffs_symlink(const YCHAR *oldpath, const YCHAR *newpath)
        YCHAR *name;
        int retVal= -1;
        int mode = 0; // ignore for now
-       
+
        yaffsfs_Lock();
        parent = yaffsfs_FindDirectory(NULL,newpath,&name,0);
        obj = yaffs_MknodSymLink(parent,name,mode,0,0,oldpath);
@@ -1832,11 +1859,11 @@ int yaffs_symlink(const YCHAR *oldpath, const YCHAR *newpath)
                yaffsfs_SetError(-ENOSPC); // just assume no space for now
                retVal = -1;
        }
-       
+
        yaffsfs_Unlock();
-       
+
        return retVal;
-       
+
 }
 
 int yaffs_readlink(const YCHAR *path, YCHAR *buf, int bufsiz)
@@ -1844,11 +1871,11 @@ int yaffs_readlink(const YCHAR *path, YCHAR *buf, int bufsiz)
        yaffs_Object *obj = NULL;
        int retVal;
 
-               
+
        yaffsfs_Lock();
-       
+
        obj = yaffsfs_FindObject(NULL,path,0);
-       
+
        if(!obj)
        {
                yaffsfs_SetError(-ENOENT);
@@ -1877,12 +1904,12 @@ int yaffs_link(const YCHAR *oldpath, const YCHAR *newpath)
        yaffs_Object *target = NULL;
        int retVal = 0;
 
-               
+
        yaffsfs_Lock();
-       
+
        obj = yaffsfs_FindObject(NULL,oldpath,0);
        target = yaffsfs_FindObject(NULL,newpath,0);
-       
+
        if(!obj)
        {
                yaffsfs_SetError(-ENOENT);
@@ -1893,15 +1920,15 @@ int yaffs_link(const YCHAR *oldpath, const YCHAR *newpath)
                yaffsfs_SetError(-EEXIST);
                retVal = -1;
        }
-       else    
+       else
        {
                yaffs_Object *newdir = NULL;
                yaffs_Object *link = NULL;
-               
+
                YCHAR *newname;
-               
+
                newdir = yaffsfs_FindDirectory(NULL,newpath,&newname,0);
-               
+
                if(!newdir)
                {
                        yaffsfs_SetError(-ENOTDIR);
@@ -1926,7 +1953,7 @@ int yaffs_link(const YCHAR *oldpath, const YCHAR *newpath)
                }
        }
        yaffsfs_Unlock();
-       
+
        return retVal;
 }
 
@@ -1936,13 +1963,13 @@ int yaffs_DumpDevStruct(const YCHAR *path)
 {
 #if 0
        YCHAR *rest;
-       
+
        yaffs_Object *obj = yaffsfs_FindRoot(path,&rest);
-       
+
        if(obj)
        {
                yaffs_Device *dev = obj->myDev;
-               
+
                printf("\n"
                           "nPageWrites.......... %d\n"
                           "nPageReads........... %d\n"
@@ -1958,7 +1985,7 @@ int yaffs_DumpDevStruct(const YCHAR *path)
                                dev->garbageCollections,
                                dev->passiveGarbageCollections
                );
-               
+
        }
 
 #endif