yaffs Yet more tests for quick tests.

[yaffs2.git] / direct / yaffsfs.c

diff --git a/direct/yaffsfs.c b/direct/yaffsfs.c
index ea3322374a2b26562af4ecc59ae9caf3faf72909..41d37f46601f1939e90ea883ec2002b1e348b3d6 100644 (file)
--- a/direct/yaffsfs.c
+++ b/direct/yaffsfs.c
@@ -31,8 +31,8 @@
 #define YAFFSFS_RW_SIZE  (1<<YAFFSFS_RW_SHIFT)
 
 /* Some forward references */
 #define YAFFSFS_RW_SIZE  (1<<YAFFSFS_RW_SHIFT)
 
 /* Some forward references */

-static yaffs_obj_t *yaffsfs_FindObject(yaffs_obj_t *relativeDirectory, const YCHAR *path, int symDepth, int getEquiv);
-static void yaffsfs_RemoveObjectCallback(yaffs_obj_t *obj);
+static struct yaffs_obj *yaffsfs_FindObject(struct yaffs_obj *relativeDirectory, const YCHAR *path, int symDepth, int getEquiv);
+static void yaffsfs_RemoveObjectCallback(struct yaffs_obj *obj);

 
 unsigned int yaffs_wr_attempts;
 
 
 unsigned int yaffs_wr_attempts;
 


@@ -49,24 +49,36 @@ unsigned int yaffs_wr_attempts;
 
 typedef struct {
        int count;      /* Number of handles accessing this inode */
 
 typedef struct {
        int count;      /* Number of handles accessing this inode */

-       yaffs_obj_t *iObj;
+       struct yaffs_obj *iObj;

 } yaffsfs_Inode;
 
 typedef struct{
 } yaffsfs_Inode;
 
 typedef struct{

-       __u8    reading:1;
-       __u8    writing:1;
-       __u8    append:1;
-       __u8    shareRead:1;
-       __u8    shareWrite:1;
+       u8      reading:1;
+       u8      writing:1;
+       u8      append:1;
+       u8      shareRead:1;
+       u8      shareWrite:1;

        int     inodeId:12;     /* Index to corresponding yaffsfs_Inode */
        int     useCount:10;    /* Use count for this handle */
        int     inodeId:12;     /* Index to corresponding yaffsfs_Inode */
        int     useCount:10;    /* Use count for this handle */

-       __u32 position;         /* current position in file */
+       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_Handle;
 
 static yaffsfs_Inode yaffsfs_inode[YAFFSFS_N_HANDLES];
 static yaffsfs_Handle yaffsfs_handle[YAFFSFS_N_HANDLES];
 static int yaffsfs_handlesInitialised;
 

+
+unsigned yaffs_set_trace(unsigned  tm) 
+{
+       yaffs_trace_mask = tm;
+       return yaffs_trace_mask;
+}
+
+unsigned yaffs_get_trace(void)
+{
+       return yaffs_trace_mask;
+}
+

 /*
  * yaffsfs_InitHandle
  * Inilitalise handle management on start-up.
 /*
  * yaffsfs_InitHandle
  * Inilitalise handle management on start-up.


@@ -102,7 +114,7 @@ yaffsfs_Inode *yaffsfs_GetInodePointer(int handle)
        return NULL;
 }
 
        return NULL;
 }
 

-yaffs_obj_t *yaffsfs_GetHandleObject(int handle)
+struct yaffs_obj *yaffsfs_GetHandleObject(int handle)

 {
        yaffsfs_Inode *in = yaffsfs_GetInodePointer(handle);
 
 {
        yaffsfs_Inode *in = yaffsfs_GetInodePointer(handle);
 


@@ -117,7 +129,7 @@ yaffs_obj_t *yaffsfs_GetHandleObject(int handle)
  * Find the inode entry for an object, if it exists.
  */
 
  * Find the inode entry for an object, if it exists.
  */
 

-static int yaffsfs_FindInodeIdForObject(yaffs_obj_t *obj)
+static int yaffsfs_FindInodeIdForObject(struct yaffs_obj *obj)

 {
        int i;
        int ret = -1;
 {
        int i;
        int ret = -1;


@@ -137,7 +149,7 @@ static int yaffsfs_FindInodeIdForObject(yaffs_obj_t *obj)
  * yaffsfs_GetInodeIdForObject
  * Grab an inode entry when opening a new inode.
  */
  * yaffsfs_GetInodeIdForObject
  * Grab an inode entry when opening a new inode.
  */

-static int yaffsfs_GetInodeIdForObject(yaffs_obj_t *obj)
+static int yaffsfs_GetInodeIdForObject(struct yaffs_obj *obj)

 {
        int i;
        int ret;
 {
        int i;
        int ret;


@@ -166,7 +178,7 @@ static int yaffsfs_GetInodeIdForObject(yaffs_obj_t *obj)
 }
 
 
 }
 
 

-static int yaffsfs_CountHandles(yaffs_obj_t *obj)
+static int yaffsfs_CountHandles(struct yaffs_obj *obj)

 {
        int i = yaffsfs_FindInodeIdForObject(obj);
 
 {
        int i = yaffsfs_FindInodeIdForObject(obj);
 


@@ -178,7 +190,7 @@ static int yaffsfs_CountHandles(yaffs_obj_t *obj)
 
 static void yaffsfs_ReleaseInode(yaffsfs_Inode *in)
 {
 
 static void yaffsfs_ReleaseInode(yaffsfs_Inode *in)
 {

-       yaffs_obj_t *obj;
+       struct yaffs_obj *obj;

        
        obj = in->iObj;
 
        
        obj = in->iObj;
 


@@ -265,7 +277,7 @@ static int yaffsfs_PutHandle(int handle)
 
 
 /*
 
 
 /*

- *  Stuff to search for a directory from a path
+ *  Stuff to handle names.

  */
 
 
  */
 
 


@@ -288,9 +300,24 @@ int yaffsfs_IsPathDivider(YCHAR ch)
        return 0;
 }
 
        return 0;
 }
 

+int yaffsfs_CheckNameLength(const char *name)
+{
+       int retVal = 0;         

 
 

+       int nameLength = yaffs_strnlen(name,YAFFS_MAX_NAME_LENGTH+1);
+               
+       if(nameLength == 0){
+               yaffsfs_SetError(-ENOENT);
+               retVal = -1;
+       } else if (nameLength > YAFFS_MAX_NAME_LENGTH){
+               yaffsfs_SetError(-ENAMETOOLONG);
+               retVal = -1;
+       }

 
 

-YLIST_HEAD(yaffsfs_deviceList);
+       return retVal;  
+}
+
+LIST_HEAD(yaffsfs_deviceList);

 
 /*
  * yaffsfs_FindDevice
 
 /*
  * yaffsfs_FindDevice


@@ -299,13 +326,13 @@ YLIST_HEAD(yaffsfs_deviceList);
  * Curveballs: Should match paths that end in '/' too
  * Curveball2 Might have "/x/ and "/x/y". Need to return the longest match
  */
  * Curveballs: Should match paths that end in '/' too
  * Curveball2 Might have "/x/ and "/x/y". Need to return the longest match
  */

-static yaffs_dev_t *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPath)
+static struct yaffs_dev *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPath)

 {
 {

-       struct ylist_head *cfg;
+       struct list_head *cfg;

        const YCHAR *leftOver;
        const YCHAR *p;
        const YCHAR *leftOver;
        const YCHAR *p;

-       yaffs_dev_t *retval = NULL;
-       yaffs_dev_t *dev = NULL;
+       struct yaffs_dev *retval = NULL;
+       struct yaffs_dev *dev = NULL;

        int thisMatchLength;
        int longestMatch = -1;
        int matching;
        int thisMatchLength;
        int longestMatch = -1;
        int matching;


@@ -315,8 +342,8 @@ static yaffs_dev_t *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPath)
         * 1) Actually matches a prefix (ie /a amd /abc will not match
         * 2) Matches the longest.
         */
         * 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_dev_t, dev_list);
+       list_for_each(cfg, &yaffsfs_deviceList){
+               dev = list_entry(cfg, struct yaffs_dev, dev_list);

                leftOver = path;
                p = dev->param.name;
                thisMatchLength = 0;
                leftOver = path;
                p = dev->param.name;
                thisMatchLength = 0;


@@ -370,53 +397,11 @@ static yaffs_dev_t *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPath)
        return retval;
 }
 
        return retval;
 }
 

-#if 0
-static yaffs_dev_t *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPath)
-{
-       yaffsfs_DeviceConfiguration *cfg = yaffsfs_configurationList;
-       const YCHAR *leftOver;
-       const YCHAR *p;
-       yaffs_dev_t *retval = NULL;
-       int thisMatchLength;
-       int longestMatch = -1;

 
 

-       /*
-        * Check all configs, choose the one that:
-        * 1) Actually matches a prefix (ie /a amd /abc will not match
-        * 2) Matches the longest.
-        */
-       while(cfg && cfg->prefix && cfg->dev){
-               leftOver = path;
-               p = cfg->prefix;
-               thisMatchLength = 0;
-
-               while(*p &&  /* unmatched part of prefix */
-                     !(yaffsfs_IsPathDivider(*p) && (p[1] == 0)) &&
-                     *leftOver && yaffsfs_Match(*p,*leftOver)){
-                       p++;
-                       leftOver++;
-                       thisMatchLength++;
-               }
-
-
-               if((!*p || (yaffsfs_IsPathDivider(*p) && (p[1] == 0))) &&  /* end of prefix */
-                  (!*leftOver || yaffsfs_IsPathDivider(*leftOver)) && /* no more in this path name part */
-                  (thisMatchLength > longestMatch)){
-                       /* Matched prefix */
-                       *restOfPath = (YCHAR *)leftOver;
-                       retval = cfg->dev;
-                       longestMatch = thisMatchLength;
-               }
-               cfg++;
-       }
-       return retval;
-}
-#endif
-
-static yaffs_obj_t *yaffsfs_FindRoot(const YCHAR *path, YCHAR **restOfPath)
+static struct yaffs_obj *yaffsfs_FindRoot(const YCHAR *path, YCHAR **restOfPath)

 {
 
 {
 

-       yaffs_dev_t *dev;
+       struct yaffs_dev *dev;

 
        dev= yaffsfs_FindDevice(path,restOfPath);
        if(dev && dev->is_mounted){
 
        dev= yaffsfs_FindDevice(path,restOfPath);
        if(dev && dev->is_mounted){


@@ -425,7 +410,7 @@ static yaffs_obj_t *yaffsfs_FindRoot(const YCHAR *path, YCHAR **restOfPath)
        return NULL;
 }
 
        return NULL;
 }
 

-static yaffs_obj_t *yaffsfs_FollowLink(yaffs_obj_t *obj,int symDepth)
+static struct yaffs_obj *yaffsfs_FollowLink(struct yaffs_obj *obj,int symDepth)

 {
 
        if(obj)
 {
 
        if(obj)


@@ -451,10 +436,10 @@ static yaffs_obj_t *yaffsfs_FollowLink(yaffs_obj_t *obj,int symDepth)
  *
  * eg. "/data/xx/ff" --> puts name="ff" and returns the directory "/data/xx"
  */
  *
  * eg. "/data/xx/ff" --> puts name="ff" and returns the directory "/data/xx"
  */

-static yaffs_obj_t *yaffsfs_DoFindDirectory(yaffs_obj_t *startDir,
+static struct yaffs_obj *yaffsfs_DoFindDirectory(struct yaffs_obj *startDir,

                                const YCHAR *path, YCHAR **name, int symDepth)
 {
                                const YCHAR *path, YCHAR **name, int symDepth)
 {

-       yaffs_obj_t *dir;
+       struct yaffs_obj *dir;

        YCHAR *restOfPath;
        YCHAR str[YAFFS_MAX_NAME_LENGTH+1];
        int i;
        YCHAR *restOfPath;
        YCHAR str[YAFFS_MAX_NAME_LENGTH+1];
        int i;


@@ -514,7 +499,7 @@ static yaffs_obj_t *yaffsfs_DoFindDirectory(yaffs_obj_t *startDir,
        return NULL;
 }
 
        return NULL;
 }
 

-static yaffs_obj_t *yaffsfs_FindDirectory(yaffs_obj_t *relativeDirectory,
+static struct yaffs_obj *yaffsfs_FindDirectory(struct yaffs_obj *relativeDirectory,

                                        const YCHAR *path,YCHAR **name,int symDepth)
 {
        return yaffsfs_DoFindDirectory(relativeDirectory,path,name,symDepth);
                                        const YCHAR *path,YCHAR **name,int symDepth)
 {
        return yaffsfs_DoFindDirectory(relativeDirectory,path,name,symDepth);


@@ -523,10 +508,10 @@ static yaffs_obj_t *yaffsfs_FindDirectory(yaffs_obj_t *relativeDirectory,
 /*
  * 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_obj_t *yaffsfs_FindObject(yaffs_obj_t *relativeDirectory, const YCHAR *path,int symDepth, int getEquiv)
+static struct yaffs_obj *yaffsfs_FindObject(struct yaffs_obj *relativeDirectory, const YCHAR *path,int symDepth, int getEquiv)

 {
 {

-       yaffs_obj_t *dir;
-       yaffs_obj_t *obj;
+       struct yaffs_obj *dir;
+       struct yaffs_obj *obj;

        YCHAR *name;
 
        dir = yaffsfs_FindDirectory(relativeDirectory,path,&name,symDepth);
        YCHAR *name;
 
        dir = yaffsfs_FindDirectory(relativeDirectory,path,&name,symDepth);


@@ -575,8 +560,8 @@ int yaffs_dup(int fd)
 
 int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing)
 {
 
 int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing)
 {

-       yaffs_obj_t *obj = NULL;
-       yaffs_obj_t *dir = NULL;
+       struct yaffs_obj *obj = NULL;
+       struct yaffs_obj *dir = NULL;

        YCHAR *name;
        int handle = -1;
        yaffsfs_Handle *yh = NULL;
        YCHAR *name;
        int handle = -1;
        yaffsfs_Handle *yh = NULL;


@@ -584,14 +569,14 @@ int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing)
        int symDepth = 0;
        int errorReported = 0;
        int rwflags = oflag & ( O_RDWR | O_RDONLY | O_WRONLY);
        int symDepth = 0;
        int errorReported = 0;
        int rwflags = oflag & ( O_RDWR | O_RDONLY | O_WRONLY);

-       __u8 shareRead = (sharing & YAFFS_SHARE_READ) ?  1 : 0;
-       __u8 shareWrite = (sharing & YAFFS_SHARE_WRITE) ? 1 : 0;
-       __u8 sharedReadAllowed;
-       __u8 sharedWriteAllowed;
-       __u8 alreadyReading;
-       __u8 alreadyWriting;
-       __u8 readRequested;
-       __u8 writeRequested;
+       u8 shareRead = (sharing & YAFFS_SHARE_READ) ?  1 : 0;
+       u8 shareWrite = (sharing & YAFFS_SHARE_WRITE) ? 1 : 0;
+       u8 sharedReadAllowed;
+       u8 sharedWriteAllowed;
+       u8 alreadyReading;
+       u8 alreadyWriting;
+       u8 readRequested;
+       u8 writeRequested;

 
        /* O_EXCL only has meaning if O_CREAT is specified */
        if(!(oflag & O_CREAT))
 
        /* O_EXCL only has meaning if O_CREAT is specified */
        if(!(oflag & O_CREAT))


@@ -612,7 +597,10 @@ int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing)
 
        handle = yaffsfs_GetNewHandle();
 
 
        handle = yaffsfs_GetNewHandle();
 

-       if(handle >= 0){
+       if(handle < 0){
+               yaffsfs_SetError(-ENFILE);
+               errorReported = 1;
+       } else {

 
                yh = yaffsfs_GetHandlePointer(handle);
 
 
                yh = yaffsfs_GetHandlePointer(handle);
 


@@ -626,6 +614,7 @@ int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing)
                        obj->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY)
                        obj = NULL;
 
                        obj->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY)
                        obj = NULL;
 

+

                if(obj){
 
                        /* The file already exists or it might be a directory */
                if(obj){
 
                        /* The file already exists or it might be a directory */


@@ -640,7 +629,7 @@ int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing)
                        /* Open should fail if O_CREAT and O_EXCL are specified since
                         * the file exists
                         */
                        /* Open should fail if O_CREAT and O_EXCL are specified since
                         * the file exists
                         */

-                       if((oflag & O_EXCL) && (oflag & O_CREAT)){
+                       if(!errorReported && (oflag & O_EXCL) && (oflag & O_CREAT)){

                                openDenied = 1;
                                yaffsfs_SetError(-EEXIST);
                                errorReported = 1;
                                openDenied = 1;
                                yaffsfs_SetError(-EEXIST);
                                errorReported = 1;


@@ -653,8 +642,14 @@ int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing)
                        if( writeRequested && !(obj->yst_mode & S_IWRITE))
                                openDenied = 1;
 
                        if( writeRequested && !(obj->yst_mode & S_IWRITE))
                                openDenied = 1;
 

+                       if(openDenied && !errorReported ) {
+                               /* Error if the file exists but permissions are refused. */
+                               yaffsfs_SetError(-EACCES);
+                               errorReported = 1;
+                       }
+

                        /* Check sharing of an existing object. */
                        /* Check sharing of an existing object. */

-                       {
+                       if(!openDenied){

                                yaffsfs_Handle *hx;
                                int i;
                                sharedReadAllowed = 1;
                                yaffsfs_Handle *hx;
                                int i;
                                sharedReadAllowed = 1;


@@ -689,20 +684,39 @@ int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing)
                                }
                        }
 
                                }
                        }
 

-               } else if((oflag & O_CREAT)) {
-                       /* Let's see if we can create this file */
+               }
+
+               /* If we could not open an existing object, then let's see if
+                * the directory exists. If not, error.
+                */
+               if(!obj && !errorReported){

                        dir = yaffsfs_FindDirectory(NULL,path,&name,0);
                        dir = yaffsfs_FindDirectory(NULL,path,&name,0);

-                       if(dir  && dir->my_dev->read_only){
+                       if(!dir){
+                               yaffsfs_SetError(-ENOTDIR);
+                               errorReported = 1;
+                       }
+               }
+
+               if(!obj && dir && !errorReported && (oflag & O_CREAT)) {
+                       /* Let's see if we can create this file if it does not exist. */
+                       if(dir->my_dev->read_only){

                                yaffsfs_SetError(-EINVAL);
                                errorReported = 1;
                                yaffsfs_SetError(-EINVAL);
                                errorReported = 1;

-                       } else if(dir)
+                       } else

                                obj = yaffs_create_file(dir,name,mode,0,0);
                                obj = yaffs_create_file(dir,name,mode,0,0);

-                       else {
-                               yaffsfs_SetError(-ENOTDIR);
+
+                       if(!obj && !errorReported){
+                               yaffsfs_SetError(-ENOSPC);

                                errorReported = 1;
                        }
                }
 
                                errorReported = 1;
                        }
                }
 

+               if(!obj && dir && !errorReported && !(oflag & O_CREAT)) {
+                       /* Error if the file does not exist and CREAT is not set. */
+                       yaffsfs_SetError(-ENOENT);
+                       errorReported = 1;
+               }
+

                if(obj && !openDenied) {
                        int inodeId = yaffsfs_GetInodeIdForObject(obj);
 
                if(obj && !openDenied) {
                        int inodeId = yaffsfs_GetInodeIdForObject(obj);
 


@@ -728,10 +742,8 @@ int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing)
                                 yaffs_resize_file(obj,0);
                } else {
                        yaffsfs_PutHandle(handle);
                                 yaffs_resize_file(obj,0);
                } else {
                        yaffsfs_PutHandle(handle);

-                       if(!errorReported) {
-                               yaffsfs_SetError(-EACCES);
-                               errorReported = 1;
-                       }
+                       if(!errorReported) 
+                               yaffsfs_SetError(0); /* Problem */

                        handle = -1;
                }
        }
                        handle = -1;
                }
        }


@@ -814,14 +826,14 @@ int yaffs_close(int fd)
 int yaffsfs_do_read(int fd, void *vbuf, unsigned int nbyte, int isPread, int offset)
 {
        yaffsfs_Handle *h = NULL;
 int yaffsfs_do_read(int fd, void *vbuf, unsigned int nbyte, int isPread, int offset)
 {
        yaffsfs_Handle *h = NULL;

-       yaffs_obj_t *obj = NULL;
+       struct yaffs_obj *obj = NULL;

        int pos = 0;
        int startPos = 0;
        int nRead = 0;
        int nToRead = 0;
        int totalRead = 0;
        unsigned int maxRead;
        int pos = 0;
        int startPos = 0;
        int nRead = 0;
        int nToRead = 0;
        int totalRead = 0;
        unsigned int maxRead;

-       __u8 *buf = (__u8 *)vbuf;
+       u8 *buf = (u8 *)vbuf;

 
        yaffsfs_Lock();
        h = yaffsfs_GetHandlePointer(fd);
 
        yaffsfs_Lock();
        h = yaffsfs_GetHandlePointer(fd);


@@ -910,14 +922,14 @@ int yaffs_pread(int fd, void *buf, unsigned int nbyte, unsigned int offset)
 int yaffsfs_do_write(int fd, const void *vbuf, unsigned int nbyte, int isPwrite, int offset)
 {
        yaffsfs_Handle *h = NULL;
 int yaffsfs_do_write(int fd, const void *vbuf, unsigned int nbyte, int isPwrite, int offset)
 {
        yaffsfs_Handle *h = NULL;

-       yaffs_obj_t *obj = NULL;
+       struct yaffs_obj *obj = NULL;

        int pos = 0;
        int startPos = 0;
        int nWritten = 0;
        int totalWritten = 0;
        int write_trhrough = 0;
        int nToWrite = 0;
        int pos = 0;
        int startPos = 0;
        int nWritten = 0;
        int totalWritten = 0;
        int write_trhrough = 0;
        int nToWrite = 0;

-       const __u8 *buf = (const __u8 *)vbuf;
+       const u8 *buf = (const u8 *)vbuf;

 
        yaffsfs_Lock();
        h = yaffsfs_GetHandlePointer(fd);
 
        yaffsfs_Lock();
        h = yaffsfs_GetHandlePointer(fd);


@@ -997,7 +1009,7 @@ int yaffs_pwrite(int fd, const void *buf, unsigned int nbyte, unsigned int offse
 
 int yaffs_truncate(const YCHAR *path,off_t new_size)
 {
 
 int yaffs_truncate(const YCHAR *path,off_t new_size)
 {

-       yaffs_obj_t *obj = NULL;
+       struct yaffs_obj *obj = NULL;

        int result = YAFFS_FAIL;
 
        yaffsfs_Lock();
        int result = YAFFS_FAIL;
 
        yaffsfs_Lock();


@@ -1009,20 +1021,21 @@ int yaffs_truncate(const YCHAR *path,off_t new_size)
        else if(obj->variant_type != YAFFS_OBJECT_TYPE_FILE)
                yaffsfs_SetError(-EISDIR);
        else if(obj->my_dev->read_only)
        else if(obj->variant_type != YAFFS_OBJECT_TYPE_FILE)
                yaffsfs_SetError(-EISDIR);
        else if(obj->my_dev->read_only)

+               yaffsfs_SetError(-EACCES);
+       else if(new_size < 0 || new_size > YAFFS_MAX_FILE_SIZE)

                yaffsfs_SetError(-EINVAL);
        else
                result = yaffs_resize_file(obj,new_size);
 
        yaffsfs_Unlock();
 
                yaffsfs_SetError(-EINVAL);
        else
                result = yaffs_resize_file(obj,new_size);
 
        yaffsfs_Unlock();
 

-

        return (result) ? 0 : -1;
 }
 
 int yaffs_ftruncate(int fd, off_t new_size)
 {
        yaffsfs_Handle *h = NULL;
        return (result) ? 0 : -1;
 }
 
 int yaffs_ftruncate(int fd, off_t new_size)
 {
        yaffsfs_Handle *h = NULL;

-       yaffs_obj_t *obj = NULL;
+       struct yaffs_obj *obj = NULL;

        int result = 0;
 
        yaffsfs_Lock();
        int result = 0;
 
        yaffsfs_Lock();


@@ -1033,13 +1046,14 @@ int yaffs_ftruncate(int fd, off_t new_size)
                /* bad handle */
                yaffsfs_SetError(-EBADF);
        else if(obj->my_dev->read_only)
                /* bad handle */
                yaffsfs_SetError(-EBADF);
        else if(obj->my_dev->read_only)

+               yaffsfs_SetError(-EACCES);
+       else if( new_size < 0 || new_size > YAFFS_MAX_FILE_SIZE)

                yaffsfs_SetError(-EINVAL);
        else
                /* resize the file */
                result = yaffs_resize_file(obj,new_size);
        yaffsfs_Unlock();
 
                yaffsfs_SetError(-EINVAL);
        else
                /* resize the file */
                result = yaffs_resize_file(obj,new_size);
        yaffsfs_Unlock();
 

-

        return (result) ? 0 : -1;
 
 }
        return (result) ? 0 : -1;
 
 }


@@ -1047,7 +1061,7 @@ int yaffs_ftruncate(int fd, off_t new_size)
 off_t yaffs_lseek(int fd, off_t offset, int whence)
 {
        yaffsfs_Handle *h = NULL;
 off_t yaffs_lseek(int fd, off_t offset, int whence)
 {
        yaffsfs_Handle *h = NULL;

-       yaffs_obj_t *obj = NULL;
+       struct yaffs_obj *obj = NULL;

        int pos = -1;
        int fSize = -1;
 
        int pos = -1;
        int fSize = -1;
 


@@ -1055,30 +1069,28 @@ off_t yaffs_lseek(int fd, off_t offset, int whence)
        h = yaffsfs_GetHandlePointer(fd);
        obj = yaffsfs_GetHandleObject(fd);
 
        h = yaffsfs_GetHandlePointer(fd);
        obj = yaffsfs_GetHandleObject(fd);
 

-       if(!h || !obj)
+       if(!h || !obj){

                /* bad handle */
                yaffsfs_SetError(-EBADF);
                /* bad handle */
                yaffsfs_SetError(-EBADF);

-       else if(whence == SEEK_SET){
-               if(offset >= 0)
-                       pos = offset;
-       }
-       else if(whence == SEEK_CUR) {
-               if( (h->position + offset) >= 0)
-                       pos = (h->position + offset);
-       }
-       else if(whence == SEEK_END) {
-               fSize = yaffs_get_obj_length(obj);
-               if(fSize >= 0 && (fSize + offset) >= 0)
-                       pos = fSize + offset;
-       }
-
-       if(pos >= 0)
-               h->position = pos;
-       else {
-               /* todo error */
+       } else {
+               if(whence == SEEK_SET){
+                       if(offset >= 0)
+                               pos = offset;
+               } else if(whence == SEEK_CUR) {
+                       if( (h->position + offset) >= 0)
+                               pos = (h->position + offset);
+               } else if(whence == SEEK_END) {
+                       fSize = yaffs_get_obj_length(obj);
+                       if(fSize >= 0 && (fSize + offset) >= 0)
+                               pos = fSize + offset;
+               } 
+
+               if(pos >= 0)
+                       h->position = pos;
+               else
+                       yaffsfs_SetError(-EINVAL);

        }
 
        }
 

-

        yaffsfs_Unlock();
 
        return pos;
        yaffsfs_Unlock();
 
        return pos;


@@ -1087,8 +1099,8 @@ off_t yaffs_lseek(int fd, off_t offset, int whence)
 
 int yaffsfs_DoUnlink(const YCHAR *path,int isDirectory)
 {
 
 int yaffsfs_DoUnlink(const YCHAR *path,int isDirectory)
 {

-       yaffs_obj_t *dir = NULL;
-       yaffs_obj_t *obj = NULL;
+       struct yaffs_obj *dir = NULL;
+       struct yaffs_obj *obj = NULL;

        YCHAR *name;
        int result = YAFFS_FAIL;
 
        YCHAR *name;
        int result = YAFFS_FAIL;
 


@@ -1133,9 +1145,9 @@ int yaffs_unlink(const YCHAR *path)
 
 int yaffs_rename(const YCHAR *oldPath, const YCHAR *newPath)
 {
 
 int yaffs_rename(const YCHAR *oldPath, const YCHAR *newPath)
 {

-       yaffs_obj_t *olddir = NULL;
-       yaffs_obj_t *newdir = NULL;
-       yaffs_obj_t *obj = NULL;
+       struct yaffs_obj *olddir = NULL;
+       struct yaffs_obj *newdir = NULL;
+       struct yaffs_obj *obj = NULL;

        YCHAR *oldname;
        YCHAR *newname;
        int result= YAFFS_FAIL;
        YCHAR *oldname;
        YCHAR *newname;
        int result= YAFFS_FAIL;


@@ -1155,8 +1167,7 @@ int yaffs_rename(const YCHAR *oldPath, const YCHAR *newPath)
                yaffsfs_SetError(-EINVAL);
                rename_allowed = 0;
        } else if(olddir->my_dev != newdir->my_dev) {
                yaffsfs_SetError(-EINVAL);
                rename_allowed = 0;
        } else if(olddir->my_dev != newdir->my_dev) {

-               /* oops must be on same device */
-               /* todo error */
+               /* Rename must be on same device */

                yaffsfs_SetError(-EXDEV);
                rename_allowed = 0;
        } else if(obj && obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) {
                yaffsfs_SetError(-EXDEV);
                rename_allowed = 0;
        } else if(obj && obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) {


@@ -1166,7 +1177,7 @@ int yaffs_rename(const YCHAR *oldPath, const YCHAR *newPath)
                 * Do this by tracing from the new directory back to the root, checking for obj
                 */
 
                 * Do this by tracing from the new directory back to the root, checking for obj
                 */
 

-               yaffs_obj_t *xx = newdir;
+               struct yaffs_obj *xx = newdir;

 
                while( rename_allowed && xx){
                        if(xx == obj)
 
                while( rename_allowed && xx){
                        if(xx == obj)


@@ -1186,7 +1197,7 @@ int yaffs_rename(const YCHAR *oldPath, const YCHAR *newPath)
 }
 
 
 }
 
 

-static int yaffsfs_DoStat(yaffs_obj_t *obj,struct yaffs_stat *buf)
+static int yaffsfs_DoStat(struct yaffs_obj *obj,struct yaffs_stat *buf)

 {
        int retVal = -1;
 
 {
        int retVal = -1;
 


@@ -1230,7 +1241,7 @@ static int yaffsfs_DoStat(yaffs_obj_t *obj,struct yaffs_stat *buf)
 
 static int yaffsfs_DoStatOrLStat(const YCHAR *path, struct yaffs_stat *buf,int doLStat)
 {
 
 static int yaffsfs_DoStatOrLStat(const YCHAR *path, struct yaffs_stat *buf,int doLStat)
 {

-       yaffs_obj_t *obj;
+       struct yaffs_obj *obj;

 
        int retVal = -1;
 
 
        int retVal = -1;
 


@@ -1265,7 +1276,7 @@ int yaffs_lstat(const YCHAR *path, struct yaffs_stat *buf)
 
 int yaffs_fstat(int fd, struct yaffs_stat *buf)
 {
 
 int yaffs_fstat(int fd, struct yaffs_stat *buf)
 {

-       yaffs_obj_t *obj;
+       struct yaffs_obj *obj;

 
        int retVal = -1;
 
 
        int retVal = -1;
 


@@ -1289,7 +1300,7 @@ int yaffs_fstat(int fd, struct yaffs_stat *buf)
 
 static int yaffs_do_setxattr(const YCHAR *path, const char *name, const void *data, int size, int flags, int follow)
 {
 
 static int yaffs_do_setxattr(const YCHAR *path, const char *name, const void *data, int size, int flags, int follow)
 {

-       yaffs_obj_t *obj;
+       struct yaffs_obj *obj;

 
        int retVal = -1;
 
 
        int retVal = -1;
 


@@ -1330,7 +1341,7 @@ int yaffs_lsetxattr(const YCHAR *path, const char *name, const void *data, int s
 
 int yaffs_fsetxattr(int fd, const char *name, const void *data, int size, int flags)
 {
 
 int yaffs_fsetxattr(int fd, const char *name, const void *data, int size, int flags)
 {

-       yaffs_obj_t *obj;
+       struct yaffs_obj *obj;

 
        int retVal = -1;
 
 
        int retVal = -1;
 


@@ -1354,7 +1365,7 @@ int yaffs_fsetxattr(int fd, const char *name, const void *data, int size, int fl
 
 static int yaffs_do_getxattr(const YCHAR *path, const char *name, void *data, int size, int follow)
 {
 
 static int yaffs_do_getxattr(const YCHAR *path, const char *name, void *data, int size, int follow)
 {

-       yaffs_obj_t *obj;
+       struct yaffs_obj *obj;

 
        int retVal = -1;
 
 
        int retVal = -1;
 


@@ -1394,7 +1405,7 @@ int yaffs_lgetxattr(const YCHAR *path, const char *name, void *data, int size)
 
 int yaffs_fgetxattr(int fd, const char *name, void *data, int size)
 {
 
 int yaffs_fgetxattr(int fd, const char *name, void *data, int size)
 {

-       yaffs_obj_t *obj;
+       struct yaffs_obj *obj;

 
        int retVal = -1;
 
 
        int retVal = -1;
 


@@ -1418,7 +1429,7 @@ int yaffs_fgetxattr(int fd, const char *name, void *data, int size)
 
 static int yaffs_do_listxattr(const YCHAR *path, char *data, int size, int follow)
 {
 
 static int yaffs_do_listxattr(const YCHAR *path, char *data, int size, int follow)
 {

-       yaffs_obj_t *obj;
+       struct yaffs_obj *obj;

 
        int retVal = -1;
 
 
        int retVal = -1;
 


@@ -1457,7 +1468,7 @@ int yaffs_llistxattr(const YCHAR *path, char *data, int size)
 
 int yaffs_flistxattr(int fd, char *data, int size)
 {
 
 int yaffs_flistxattr(int fd, char *data, int size)
 {

-       yaffs_obj_t *obj;
+       struct yaffs_obj *obj;

 
        int retVal = -1;
 
 
        int retVal = -1;
 


@@ -1481,7 +1492,7 @@ int yaffs_flistxattr(int fd, char *data, int size)
 
 static int yaffs_do_removexattr(const YCHAR *path, const char *name, int follow)
 {
 
 static int yaffs_do_removexattr(const YCHAR *path, const char *name, int follow)
 {

-       yaffs_obj_t *obj;
+       struct yaffs_obj *obj;

 
        int retVal = -1;
 
 
        int retVal = -1;
 


@@ -1520,7 +1531,7 @@ int yaffs_lremovexattr(const YCHAR *path, const char *name)
 
 int yaffs_fremovexattr(int fd, const char *name)
 {
 
 int yaffs_fremovexattr(int fd, const char *name)
 {

-       yaffs_obj_t *obj;
+       struct yaffs_obj *obj;

 
        int retVal = -1;
 
 
        int retVal = -1;
 


@@ -1546,7 +1557,7 @@ int yaffs_fremovexattr(int fd, const char *name)
 #ifdef CONFIG_YAFFS_WINCE
 int yaffs_get_wince_times(int fd, unsigned *wctime, unsigned *watime, unsigned *wmtime)
 {
 #ifdef CONFIG_YAFFS_WINCE
 int yaffs_get_wince_times(int fd, unsigned *wctime, unsigned *watime, unsigned *wmtime)
 {

-       yaffs_obj_t *obj;
+       struct yaffs_obj *obj;

 
        int retVal = -1;
 
 
        int retVal = -1;
 


@@ -1585,7 +1596,7 @@ int yaffs_set_wince_times(int fd,
                                                  const unsigned *watime, 
                                                   const unsigned *wmtime)
 {
                                                  const unsigned *watime, 
                                                   const unsigned *wmtime)
 {

-        yaffs_obj_t *obj;
+        struct yaffs_obj *obj;

         int result;
         int retVal = -1;
 
         int result;
         int retVal = -1;
 


@@ -1622,7 +1633,7 @@ int yaffs_set_wince_times(int fd,
 #endif
 
 
 #endif
 
 

-static int yaffsfs_DoChMod(yaffs_obj_t *obj,mode_t mode)
+static int yaffsfs_DoChMod(struct yaffs_obj *obj,mode_t mode)

 {
        int result = -1;
 
 {
        int result = -1;
 


@@ -1641,10 +1652,15 @@ static int yaffsfs_DoChMod(yaffs_obj_t *obj,mode_t mode)
 
 int yaffs_access(const YCHAR *path, int amode)
 {
 
 int yaffs_access(const YCHAR *path, int amode)
 {

-       yaffs_obj_t *obj;
+       struct yaffs_obj *obj;

 
        int retval = 0;
 
 
        int retval = 0;
 

+       if(amode & ~(R_OK | W_OK | X_OK)){
+               yaffsfs_SetError(-EINVAL);
+               return -1;
+       }
+

        yaffsfs_Lock();
 
        obj = yaffsfs_FindObject(NULL,path,0,1);
        yaffsfs_Lock();
 
        obj = yaffsfs_FindObject(NULL,path,0,1);


@@ -1678,7 +1694,7 @@ int yaffs_access(const YCHAR *path, int amode)
 
 int yaffs_chmod(const YCHAR *path, mode_t mode)
 {
 
 int yaffs_chmod(const YCHAR *path, mode_t mode)
 {

-       yaffs_obj_t *obj;
+       struct yaffs_obj *obj;

 
        int retVal = -1;
 
 
        int retVal = -1;
 


@@ -1702,7 +1718,7 @@ int yaffs_chmod(const YCHAR *path, mode_t mode)
 
 int yaffs_fchmod(int fd, mode_t mode)
 {
 
 int yaffs_fchmod(int fd, mode_t mode)
 {

-       yaffs_obj_t *obj;
+       struct yaffs_obj *obj;

 
        int retVal = -1;
 
 
        int retVal = -1;
 


@@ -1724,11 +1740,43 @@ int yaffs_fchmod(int fd, mode_t mode)
 
 int yaffs_mkdir(const YCHAR *path, mode_t mode)
 {
 
 int yaffs_mkdir(const YCHAR *path, mode_t mode)
 {

-       yaffs_obj_t *parent = NULL;
-       yaffs_obj_t *dir = NULL;
+       struct yaffs_obj *parent = NULL;
+       struct yaffs_obj *dir = NULL;

        YCHAR *name;
        YCHAR *name;

+       YCHAR *use_path = NULL;
+       int path_length = 0;

        int retVal= -1;
        int retVal= -1;

+       int i;
+

 
 

+       /*
+        * We don't have a definition for max path length.
+        * We will use 3 * max name length instead.
+        */
+       
+       path_length = strnlen(path,(YAFFS_MAX_NAME_LENGTH+1)*3 +1);
+
+       /* If the last character is a path divider, then we need to
+        * trim it back so that the name look-up works properly.
+        * eg. /foo/new_dir/ -> /foo/newdir
+        * Curveball: Need to handle multiple path dividers:
+        * eg. /foof/sdfse///// -> /foo/sdfse
+        */
+       if(path_length > 0 && 
+               yaffsfs_IsPathDivider(path[path_length-1])){
+               use_path = YMALLOC(path_length + 1);
+               if(!use_path){
+                       yaffsfs_SetError(-ENOMEM);
+                       return -1;
+               }
+               strcpy(use_path, path);
+               for(i = path_length-1;
+                       i >= 0 && yaffsfs_IsPathDivider(use_path[i]);
+                       i--)
+                       use_path[i] = (YCHAR) 0;
+               path = use_path;
+       }
+       

        yaffsfs_Lock();
        parent = yaffsfs_FindDirectory(NULL,path,&name,0);
        if(parent && yaffs_strnlen(name,5) == 0){
        yaffsfs_Lock();
        parent = yaffsfs_FindDirectory(NULL,path,&name,0);
        if(parent && yaffs_strnlen(name,5) == 0){


@@ -1754,12 +1802,15 @@ int yaffs_mkdir(const YCHAR *path, mode_t mode)
 
        yaffsfs_Unlock();
 
 
        yaffsfs_Unlock();
 

+       if(use_path)
+               YFREE(use_path);
+

        return retVal;
 }
 
 void * yaffs_getdev(const YCHAR *path)
 {
        return retVal;
 }
 
 void * yaffs_getdev(const YCHAR *path)
 {

-       yaffs_dev_t *dev=NULL;
+       struct yaffs_dev *dev=NULL;

        YCHAR *dummy;
        dev = yaffsfs_FindDevice(path,&dummy);
        return (void *)dev;
        YCHAR *dummy;
        dev = yaffsfs_FindDevice(path,&dummy);
        return (void *)dev;


@@ -1769,10 +1820,10 @@ int yaffs_mount2(const YCHAR *path,int read_only)
 {
        int retVal=-1;
        int result=YAFFS_FAIL;
 {
        int retVal=-1;
        int result=YAFFS_FAIL;

-       yaffs_dev_t *dev=NULL;
+       struct yaffs_dev *dev=NULL;

        YCHAR *dummy;
 
        YCHAR *dummy;
 

-       T(YAFFS_TRACE_ALWAYS,(TSTR("yaffs: Mounting %s" TENDSTR),path));
+       T(YAFFS_TRACE_MOUNT,(TSTR("yaffs: Mounting %s" TENDSTR),path));

 
        yaffsfs_Lock();
 
 
        yaffsfs_Lock();
 


@@ -1809,7 +1860,7 @@ int yaffs_mount(const YCHAR *path)
 int yaffs_sync(const YCHAR *path)
 {
         int retVal=-1;
 int yaffs_sync(const YCHAR *path)
 {
         int retVal=-1;

-        yaffs_dev_t *dev=NULL;
+        struct yaffs_dev *dev=NULL;

         YCHAR *dummy;
         
         yaffsfs_Lock();
         YCHAR *dummy;
         
         yaffsfs_Lock();


@@ -1837,7 +1888,7 @@ int yaffs_sync(const YCHAR *path)
 int yaffs_remount(const YCHAR *path, int force, int read_only)
 {
         int retVal=-1;
 int yaffs_remount(const YCHAR *path, int force, int read_only)
 {
         int retVal=-1;

-       yaffs_dev_t *dev=NULL;
+       struct yaffs_dev *dev=NULL;

        YCHAR *dummy;
 
        yaffsfs_Lock();
        YCHAR *dummy;
 
        yaffsfs_Lock();


@@ -1877,7 +1928,7 @@ int yaffs_remount(const YCHAR *path, int force, int read_only)
 int yaffs_unmount2(const YCHAR *path, int force)
 {
         int retVal=-1;
 int yaffs_unmount2(const YCHAR *path, int force)
 {
         int retVal=-1;

-       yaffs_dev_t *dev=NULL;
+       struct yaffs_dev *dev=NULL;

        YCHAR *dummy;
 
        yaffsfs_Lock();
        YCHAR *dummy;
 
        yaffsfs_Lock();


@@ -1925,7 +1976,7 @@ int yaffs_unmount(const YCHAR *path)
 loff_t yaffs_freespace(const YCHAR *path)
 {
        loff_t retVal=-1;
 loff_t yaffs_freespace(const YCHAR *path)
 {
        loff_t retVal=-1;

-       yaffs_dev_t *dev=NULL;
+       struct yaffs_dev *dev=NULL;

        YCHAR *dummy;
 
        yaffsfs_Lock();
        YCHAR *dummy;
 
        yaffsfs_Lock();


@@ -1944,7 +1995,7 @@ loff_t yaffs_freespace(const YCHAR *path)
 loff_t yaffs_totalspace(const YCHAR *path)
 {
        loff_t retVal=-1;
 loff_t yaffs_totalspace(const YCHAR *path)
 {
        loff_t retVal=-1;

-       yaffs_dev_t *dev=NULL;
+       struct yaffs_dev *dev=NULL;

        YCHAR *dummy;
 
        yaffsfs_Lock();
        YCHAR *dummy;
 
        yaffsfs_Lock();


@@ -1964,7 +2015,7 @@ loff_t yaffs_totalspace(const YCHAR *path)
 int yaffs_inodecount(const YCHAR *path)
 {
        loff_t retVal= -1;
 int yaffs_inodecount(const YCHAR *path)
 {
        loff_t retVal= -1;

-       yaffs_dev_t *dev=NULL;
+       struct yaffs_dev *dev=NULL;

        YCHAR *dummy;
 
        yaffsfs_Lock();
        YCHAR *dummy;
 
        yaffsfs_Lock();


@@ -1983,20 +2034,20 @@ int yaffs_inodecount(const YCHAR *path)
 }
 
 
 }
 
 

-void yaffs_add_device(yaffs_dev_t *dev)
+void yaffs_add_device(struct yaffs_dev *dev)

 {
        dev->is_mounted = 0;
        dev->param.remove_obj_fn = yaffsfs_RemoveObjectCallback;
 
        if(!dev->dev_list.next)
 {
        dev->is_mounted = 0;
        dev->param.remove_obj_fn = yaffsfs_RemoveObjectCallback;
 
        if(!dev->dev_list.next)

-               YINIT_LIST_HEAD(&dev->dev_list);
+               INIT_LIST_HEAD(&dev->dev_list);

 
 

-       ylist_add(&dev->dev_list,&yaffsfs_deviceList);
+       list_add(&dev->dev_list,&yaffsfs_deviceList);

 }
 
 }
 

-void yaffs_remove_device(yaffs_dev_t *dev)
+void yaffs_remove_device(struct yaffs_dev *dev)

 {
 {

-       ylist_del_init(&dev->dev_list);
+       list_del_init(&dev->dev_list);

 }
 
 
 }
 
 


@@ -2013,18 +2064,18 @@ void yaffs_remove_device(yaffs_dev_t *dev)
 
 typedef struct
 {
 
 typedef struct
 {

-       __u32 magic;
+       u32 magic;

        yaffs_dirent de;                /* directory entry being used by this dsc */
        YCHAR name[NAME_MAX+1];         /* name of directory being searched */
        yaffs_dirent de;                /* directory entry being used by this dsc */
        YCHAR name[NAME_MAX+1];         /* name of directory being searched */

-        yaffs_obj_t *dirObj;           /* ptr to directory being searched */
-        yaffs_obj_t *nextReturn;       /* obj to be returned by next readddir */
+        struct yaffs_obj *dirObj;           /* ptr to directory being searched */
+        struct yaffs_obj *nextReturn;       /* obj to be returned by next readddir */

         int offset;
         int offset;

-        struct ylist_head others;       
+        struct list_head others;       

 } yaffsfs_DirectorySearchContext;
 
 
 
 } yaffsfs_DirectorySearchContext;
 
 
 

-static struct ylist_head search_contexts;
+static struct list_head search_contexts;

 
 
 static void yaffsfs_SetDirRewound(yaffsfs_DirectorySearchContext *dsc)
 
 
 static void yaffsfs_SetDirRewound(yaffsfs_DirectorySearchContext *dsc)


@@ -2035,11 +2086,11 @@ static void yaffsfs_SetDirRewound(yaffsfs_DirectorySearchContext *dsc)
 
            dsc->offset = 0;
 
 
            dsc->offset = 0;
 

-           if( ylist_empty(&dsc->dirObj->variant.dir_variant.children))
+           if( list_empty(&dsc->dirObj->variant.dir_variant.children))

                 dsc->nextReturn = NULL;
            else
                 dsc->nextReturn = NULL;
            else

-                dsc->nextReturn = ylist_entry(dsc->dirObj->variant.dir_variant.children.next,
-                                                yaffs_obj_t,siblings);
+                dsc->nextReturn = list_entry(dsc->dirObj->variant.dir_variant.children.next,
+                                                struct yaffs_obj,siblings);

         } else {
                /* Hey someone isn't playing nice! */
        }
         } else {
                /* Hey someone isn't playing nice! */
        }


@@ -2052,25 +2103,25 @@ static void yaffsfs_DirAdvance(yaffsfs_DirectorySearchContext *dsc)
            dsc->dirObj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY){
 
            if( dsc->nextReturn == NULL ||
            dsc->dirObj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY){
 
            if( dsc->nextReturn == NULL ||

-               ylist_empty(&dsc->dirObj->variant.dir_variant.children))
+               list_empty(&dsc->dirObj->variant.dir_variant.children))

                 dsc->nextReturn = NULL;
            else {
                 dsc->nextReturn = NULL;
            else {

-                   struct ylist_head *next = dsc->nextReturn->siblings.next;
+                   struct list_head *next = dsc->nextReturn->siblings.next;

 
                    if( next == &dsc->dirObj->variant.dir_variant.children)
                         dsc->nextReturn = NULL; /* end of list */
                    else
 
                    if( next == &dsc->dirObj->variant.dir_variant.children)
                         dsc->nextReturn = NULL; /* end of list */
                    else

-                        dsc->nextReturn = ylist_entry(next,yaffs_obj_t,siblings);
+                        dsc->nextReturn = list_entry(next,struct yaffs_obj,siblings);

            }
         } else {
                 /* Hey someone isn't playing nice! */
        }
 }
 
            }
         } else {
                 /* Hey someone isn't playing nice! */
        }
 }
 

-static void yaffsfs_RemoveObjectCallback(yaffs_obj_t *obj)
+static void yaffsfs_RemoveObjectCallback(struct yaffs_obj *obj)

 {
 
 {
 

-        struct ylist_head *i;
+        struct list_head *i;

         yaffsfs_DirectorySearchContext *dsc;
 
         /* if search contexts not initilised then skip */
         yaffsfs_DirectorySearchContext *dsc;
 
         /* if search contexts not initilised then skip */


@@ -2081,9 +2132,9 @@ static void yaffsfs_RemoveObjectCallback(yaffs_obj_t *obj)
          * If any are the one being removed, then advance the dsc to
          * the next one to prevent a hanging ptr.
          */
          * If any are the one being removed, then advance the dsc to
          * the next one to prevent a hanging ptr.
          */

-         ylist_for_each(i, &search_contexts) {
+         list_for_each(i, &search_contexts) {

                 if (i) {
                 if (i) {

-                        dsc = ylist_entry(i, yaffsfs_DirectorySearchContext,others);
+                        dsc = list_entry(i, yaffsfs_DirectorySearchContext,others);

                         if(dsc->nextReturn == obj)
                                 yaffsfs_DirAdvance(dsc);
                 }
                         if(dsc->nextReturn == obj)
                                 yaffsfs_DirAdvance(dsc);
                 }


@@ -2094,7 +2145,7 @@ static void yaffsfs_RemoveObjectCallback(yaffs_obj_t *obj)
 yaffs_DIR *yaffs_opendir(const YCHAR *dirname)
 {
        yaffs_DIR *dir = NULL;
 yaffs_DIR *yaffs_opendir(const YCHAR *dirname)
 {
        yaffs_DIR *dir = NULL;

-       yaffs_obj_t *obj = NULL;
+       struct yaffs_obj *obj = NULL;

        yaffsfs_DirectorySearchContext *dsc = NULL;
 
        yaffsfs_Lock();
        yaffsfs_DirectorySearchContext *dsc = NULL;
 
        yaffsfs_Lock();


@@ -2111,12 +2162,12 @@ yaffs_DIR *yaffs_opendir(const YCHAR *dirname)
                         dsc->magic = YAFFS_MAGIC;
                         dsc->dirObj = obj;
                         yaffs_strncpy(dsc->name,dirname,NAME_MAX);
                         dsc->magic = YAFFS_MAGIC;
                         dsc->dirObj = obj;
                         yaffs_strncpy(dsc->name,dirname,NAME_MAX);

-                        YINIT_LIST_HEAD(&dsc->others);
+                        INIT_LIST_HEAD(&dsc->others);

 
                         if(!search_contexts.next)
 
                         if(!search_contexts.next)

-                                YINIT_LIST_HEAD(&search_contexts);
+                                INIT_LIST_HEAD(&search_contexts);

 
 

-                        ylist_add(&dsc->others,&search_contexts);       
+                        list_add(&dsc->others,&search_contexts);       

                         yaffsfs_SetDirRewound(dsc);
                }
 
                         yaffsfs_SetDirRewound(dsc);
                }
 


@@ -2179,7 +2230,7 @@ int yaffs_closedir(yaffs_DIR *dirp)
 
         yaffsfs_Lock();
         dsc->magic = 0;
 
         yaffsfs_Lock();
         dsc->magic = 0;

-        ylist_del(&dsc->others); /* unhook from list */
+        list_del(&dsc->others); /* unhook from list */

         YFREE(dsc);
         yaffsfs_Unlock();
         return 0;
         YFREE(dsc);
         yaffsfs_Unlock();
         return 0;


@@ -2190,8 +2241,8 @@ int yaffs_closedir(yaffs_DIR *dirp)
 
 int yaffs_symlink(const YCHAR *oldpath, const YCHAR *newpath)
 {
 
 int yaffs_symlink(const YCHAR *oldpath, const YCHAR *newpath)
 {

-       yaffs_obj_t *parent = NULL;
-       yaffs_obj_t *obj;
+       struct yaffs_obj *parent = NULL;
+       struct yaffs_obj *obj;

        YCHAR *name;
        int retVal= -1;
        int mode = 0; /* ignore for now */
        YCHAR *name;
        int retVal= -1;
        int mode = 0; /* ignore for now */


@@ -2221,10 +2272,9 @@ int yaffs_symlink(const YCHAR *oldpath, const YCHAR *newpath)
 
 int yaffs_readlink(const YCHAR *path, YCHAR *buf, int bufsiz)
 {
 
 int yaffs_readlink(const YCHAR *path, YCHAR *buf, int bufsiz)
 {

-       yaffs_obj_t *obj = NULL;
+       struct yaffs_obj *obj = NULL;

        int retVal;
 
        int retVal;
 

-

        yaffsfs_Lock();
 
        obj = yaffsfs_FindObject(NULL,path,0,1);
        yaffsfs_Lock();
 
        obj = yaffsfs_FindObject(NULL,path,0,1);


@@ -2248,11 +2298,9 @@ 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 */
 int yaffs_link(const YCHAR *oldpath, const YCHAR *newpath)
 {
        /* Creates a link called newpath to existing oldpath */

-       yaffs_obj_t *obj = NULL;
-       yaffs_obj_t *target = NULL;
+       struct yaffs_obj *obj = NULL;
+       struct yaffs_obj *target = NULL;

        int retVal = 0;
        int retVal = 0;

-       int new_nameLength = 0;
-

 
        yaffsfs_Lock();
 
 
        yaffsfs_Lock();
 


@@ -2269,8 +2317,8 @@ int yaffs_link(const YCHAR *oldpath, const YCHAR *newpath)
                yaffsfs_SetError(-EEXIST);
                retVal = -1;
        } else {
                yaffsfs_SetError(-EEXIST);
                retVal = -1;
        } else {

-               yaffs_obj_t *newdir = NULL;
-               yaffs_obj_t *link = NULL;
+               struct yaffs_obj *newdir = NULL;
+               struct yaffs_obj *link = NULL;

 
                YCHAR *newname;
 
 
                YCHAR *newname;
 


@@ -2284,15 +2332,7 @@ int yaffs_link(const YCHAR *oldpath, const YCHAR *newpath)
                        retVal = -1;
                }
                
                        retVal = -1;
                }
                

-               new_nameLength = yaffs_strnlen(newname,YAFFS_MAX_NAME_LENGTH+1);
-               
-               if(new_nameLength == 0){
-                       yaffsfs_SetError(-ENOENT);
-                       retVal = -1;
-               } else if (new_nameLength > YAFFS_MAX_NAME_LENGTH){
-                       yaffsfs_SetError(-ENAMETOOLONG);
-                       retVal = -1;
-               }
+               retVal = yaffsfs_CheckNameLength(newname);

                
                if(retVal == 0) {
                        link = yaffs_link_obj(newdir,newname,obj);
                
                if(retVal == 0) {
                        link = yaffs_link_obj(newdir,newname,obj);


@@ -2323,7 +2363,7 @@ int yaffs_mknod(const YCHAR *pathname, mode_t mode, dev_t dev)
  */
 int yaffs_n_handles(const YCHAR *path)
 {
  */
 int yaffs_n_handles(const YCHAR *path)
 {

-       yaffs_obj_t *obj;
+       struct yaffs_obj *obj;

 
        obj = yaffsfs_FindObject(NULL,path,0,1);
 
 
        obj = yaffsfs_FindObject(NULL,path,0,1);
 


@@ -2335,15 +2375,22 @@ int yaffs_get_error(void)
        return yaffsfs_GetLastError();
 }
 
        return yaffsfs_GetLastError();
 }
 

+int yaffs_set_error(int error)
+{
+       /*yaffsfs_SetError does not return. So the program is assumed to have worked. */
+       yaffsfs_SetError(error);
+       return 0;
+}
+

 int yaffs_dump_dev(const YCHAR *path)
 {
 #if 0
        YCHAR *rest;
 
 int yaffs_dump_dev(const YCHAR *path)
 {
 #if 0
        YCHAR *rest;
 

-       yaffs_obj_t *obj = yaffsfs_FindRoot(path,&rest);
+       struct yaffs_obj *obj = yaffsfs_FindRoot(path,&rest);

 
        if(obj){
 
        if(obj){

-               yaffs_dev_t *dev = obj->my_dev;
+               struct yaffs_dev *dev = obj->my_dev;

 
                printf("\n"
                           "n_page_writes.......... %d\n"
 
                printf("\n"
                           "n_page_writes.......... %d\n"