Implemented FAT write

git-svn-id: svn://svn.code.sf.net/p/nuttx/code/trunk@244 42af7a65-404d-4744-a932-0658087f49c3

4 files changed, 881 insertions, 218 deletions

diff --git a/nuttx/examples/mount/mount_main.c b/nuttx/examples/mount/mount_main.c
index 274a35010..09dc8e189 100644
--- a/nuttx/examples/mount/mount_main.c
+++ b/nuttx/examples/mount/mount_main.c
@@ -64,7 +64,7 @@ static const char g_target[]         = "/mnt/fs";
 static const char g_filesystemtype[] = "vfat";
 
 static const char g_testfile1[]      = "/mnt/fs/TestDir/TestFile.txt";
-static const char g_testfile2[]      = "/mnt/fs/TestDir/WriteTest.txt";
+static const char g_testfile2[]      = "/mnt/fs/TestDir/WritTest.txt";
 static const char g_testmsg[]        = "This is a write test";
 
 /****************************************************************************
@@ -89,7 +89,9 @@ void user_initialize(void)
 
 int user_start(int argc, char *argv[])
 {
-  int ret;
+  char buffer[128];
+  int  nbytes;
+  int  ret;
 
   printf("main: mounting %s filesystem at target=%s with source=%s\n",
          g_filesystemtype, g_target, g_source);
@@ -104,12 +106,12 @@ int user_start(int argc, char *argv[])
       int fd = open(g_testfile1, O_RDONLY);
       if (fd < 0)
         {
-          printf("main: failed open %s, errno=%d\n", g_testfile1, *get_errno_ptr());
+          printf("main: failed to open %s, errno=%d\n", g_testfile1, *get_errno_ptr());
         }
       else
         {
-          char buffer[128];
-          int nbytes = read(fd, buffer, 128);
+          memset(buffer, 0, 128);
+          nbytes = read(fd, buffer, 128);
           if (nbytes < 0)
             {
               printf("main: failed to read from %s, errno=%d\n", g_testfile1, *get_errno_ptr());
@@ -127,7 +129,7 @@ int user_start(int argc, char *argv[])
       fd = open(g_testfile2, O_WRONLY|O_CREAT|O_TRUNC, 0644);
       if (fd < 0)
         {
-          printf("main: failed open %s, errno=%d\n", g_testfile2, *get_errno_ptr());
+          printf("main: failed to open %s for writing, errno=%d\n", g_testfile2, *get_errno_ptr());
         }
       else
         {
@@ -136,6 +138,33 @@ int user_start(int argc, char *argv[])
             {
               printf("main: failed to write to %s, errno=%d\n", g_testfile2, *get_errno_ptr());
             }
+          else
+            {
+              printf("main: wrote %d bytes to %s\n", nbytes, g_testfile2);
+            }
+          close(fd);
+        }
+
+      printf("main: opening %s for reading\n", g_testfile2);
+
+      fd = open(g_testfile2, O_RDONLY);
+      if (fd < 0)
+        {
+          printf("main: failed to open %s for reading, errno=%d\n", g_testfile2, *get_errno_ptr());
+        }
+      else
+        {
+          memset(buffer, 0, 128);
+          nbytes = read(fd, buffer, 128);
+          if (nbytes < 0)
+            {
+              printf("main: failed to read from %s, errno=%d\n", g_testfile2, *get_errno_ptr());
+            }
+          else
+          {
+              buffer[127]='\0';
+              printf("main: Read \"%s\" from %s\n", buffer, g_testfile2);
+          }
           close(fd);
         }
 
diff --git a/nuttx/fs/fs_fat32.c b/nuttx/fs/fs_fat32.c
index 51441bacf..a5b68831f 100644
--- a/nuttx/fs/fs_fat32.c
+++ b/nuttx/fs/fs_fat32.c
@@ -4,6 +4,11 @@
  *   Copyright (C) 2007 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
  *
+ * References:
+ *   Microsoft FAT documentation
+ *   FAT implementation 'Copyright (C) 2007, ChaN, all right reserved.'
+ *     which has an unrestricted license.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
@@ -377,7 +382,7 @@ static ssize_t fat_read(FAR struct file *filp, char *buffer, size_t buflen)
   struct inode         *inode;
   struct fat_mountpt_s *fs;
   struct fat_file_s    *ff;
-  unsigned int          cluster;
+  uint32                cluster;
   unsigned int          bytesread;
   unsigned int          readsize;
   unsigned int          nsectors;
@@ -461,10 +466,12 @@ static ssize_t fat_read(FAR struct file *filp, char *buffer, size_t buflen)
             }
           else
             {
-              /* No.. Handle a special case of the first sector */
+              /* No.. Handle the case of the first sector of the file */
 
               if (ff->ff_position == 0)
                 {
+                  /* Get the first cluster of the file */
+
                   cluster = ff->ff_startcluster;
                 }
 
@@ -499,8 +506,8 @@ static ssize_t fat_read(FAR struct file *filp, char *buffer, size_t buflen)
           nsectors = buflen / fs->fs_hwsectorsize;
           if (nsectors > 0)
             {
-              /* Read maximum contiguous sectors directly without using
-               * our tiny read buffer.
+              /* Read maximum contiguous sectors directly to the user's
+               * buffer without using our tiny read buffer.
                *
                * Limit the number of sectors that we read on this time
                * through the loop to the remaining contiguous sectors
@@ -580,6 +587,12 @@ static ssize_t fat_write(FAR struct file *filp, const char *buffer,
   struct inode         *inode;
   struct fat_mountpt_s *fs;
   struct fat_file_s    *ff;
+  sint32                cluster;
+  size_t                writesector;
+  unsigned int          byteswritten;
+  unsigned int          writesize;
+  unsigned int          nsectors;
+  ubyte                *userbuffer = (ubyte*)buffer;
   int                   ret;
 
   /* Sanity checks */
@@ -600,12 +613,211 @@ static ssize_t fat_write(FAR struct file *filp, const char *buffer,
   ret = fat_checkmount(fs);
   if (ret != OK)
     {
-      fat_semgive(fs);
-      return ret;
+      goto errout_with_semaphore;
+    }
+
+  /* Check if the file was opened for write access */
+
+  if ((ff->ff_oflags & O_WROK) == 0)
+    {
+      ret= -EACCES;
+      goto errout_with_semaphore;
+    }
+
+  /* Check if the file size would exceed the range of size_t */
+
+  if (ff->ff_size + buflen < ff->ff_size)
+    {
+      ret = -EFBIG;
+      goto errout_with_semaphore;
+    }
+
+  /* Loop until either (1) all data has been transferred, or (2) an
+   * error occurs.
+   */
+
+  byteswritten = 0;
+  while (buflen > 0)
+    {
+      /* Get offset into the sector where we begin the read */
+
+      int sectorindex = ff->ff_position & SEC_NDXMASK(fs);
+
+      /* Check if the current read stream happens to lie on a
+       * sector boundary.
+       */
+
+      if (sectorindex == 0)
+        {
+          /* Decrement the number of sectors left in this cluster */
+
+          ff->ff_sectorsincluster--;
+
+          /* Are there unwritten sectors remaining in this cluster */
+
+          if (ff->ff_sectorsincluster > 0)
+            {
+              /* Yes.. There are more sectors in this cluster to be written.
+               * just increment the current sector number and write.
+               */
+
+              writesector = ff->ff_currentsector + 1;
+            }
+          else
+            {
+              /* No.. Handle the case of the first sector of the file */
+
+              if (ff->ff_position == 0)
+                {
+                  /* Check the first cluster of the file.  Zero means that
+                   * the file is empty -- perhaps the file was truncated or
+                   * created when it was opened
+                   */
+
+                  if (ff->ff_startcluster == 0)
+                    {
+                      /* In this case, we have to create a new cluster chain */
+
+                      ff->ff_startcluster = fat_createchain(fs);
+                    }
+
+                  /* Start writing at the first cluster of the file */
+
+                  cluster = ff->ff_startcluster;
+                }
+
+              /* But in the general case, we have to extend the current
+               * cluster by one (unless lseek was used to move the file
+               * position back from the end of the file)
+               */
+
+              else
+                {
+                    /* Extend the chain by adding a new cluster after
+                     * the last one
+                     */
+
+                    cluster = fat_extendchain(fs, ff->ff_currentcluster);
+                }
+
+              /* Verify the cluster number */
+
+              if (cluster < 0)
+                {
+                  ret = cluster;
+                  goto errout_with_semaphore;
+                }
+              else if (cluster < 2 || cluster >= fs->fs_nclusters)
+                {
+                  ret = -ENOSPC;
+                  goto errout_with_semaphore;
+                }
+
+              /* Setup to write the first sector from the new cluster */
+
+              ff->ff_currentcluster   = cluster;
+              writesector             = fat_cluster2sector(fs, cluster);
+              ff->ff_sectorsincluster = fs->fs_fatsecperclus;
+            }
+        }
+
+      /* Check if there is unwritten data in the file buffer */
+
+      ret = fat_ffcacheflush(fs, ff);
+      if (ret < 0)
+        {
+          goto errout_with_semaphore;
+        }
+
+      /* Check if the user has provided a buffer large enough to
+       * hold one or more complete sectors.
+       */
+
+      nsectors = buflen / fs->fs_hwsectorsize;
+      if (nsectors > 0)
+        {
+          /* Write maximum contiguous sectors directly from the user's
+           * buffer without using our tiny read buffer.
+           *
+           * Limit the number of sectors that we write on this time
+           * through the loop to the remaining contiguous sectors
+           * in this cluster
+           */
+
+          if (nsectors > ff->ff_sectorsincluster)
+            {
+              nsectors = ff->ff_sectorsincluster;
+            }
+
+          /* We are not sure of the state of the file buffer so
+           * the safest thing to do is just invalidate it
+           */
+
+          (void)fat_ffcacheinvalidate(fs, ff);
+
+          /* Write all of the sectors directory from user memory */
+
+          ret = fat_hwwrite(fs, userbuffer, writesector, nsectors);
+          if (ret < 0)
+            {
+              goto errout_with_semaphore;
+            }
+
+          ff->ff_sectorsincluster -= nsectors - 1;
+          writesize                = nsectors * fs->fs_hwsectorsize;
+          ff->ff_bflags           |= FFBUFF_MODIFIED;
+        }
+      else
+        {
+          /* We are write a partial sector.  We will first have to
+           * read the full sector in memory as part of a read-modify-write
+           * operation.
+           */
+
+          if (ff->ff_position < ff->ff_size)
+            {
+              ff->ff_currentsector = writesector;
+              ret = fat_ffcacheread(fs, ff, writesector);
+              if (ret < 0)
+                {
+                  goto errout_with_semaphore;
+                }
+            }
+          
+          /* Copy the partial sector from the user buffer */
+
+          writesize = fs->fs_hwsectorsize - sectorindex;
+          if (writesize > buflen)
+            {
+              writesize = buflen;
+            }
+
+          memcpy(&ff->ff_buffer[sectorindex], userbuffer, writesize);
+          ff->ff_currentsector = writesector;
+          ff->ff_bflags |= (FFBUFF_DIRTY|FFBUFF_VALID|FFBUFF_MODIFIED);
+        }
+
+      /* Set up for the next write */
+
+      userbuffer += writesize;
+      ff->ff_position += writesize;
+      byteswritten += writesize;
+      buflen -= writesize;
+    }
+
+  /* The transfer has completed without error.  Update the file size */
+
+  if (ff->ff_position > ff->ff_size)
+    {
+      ff->ff_size = ff->ff_position;
     }
 
   fat_semgive(fs);
-  return -ENOSYS;
+  return byteswritten;
+
+ errout_with_semaphore:
+  fat_semgive(fs);
+  return ret;
 }
 
 /****************************************************************************
@@ -761,7 +973,8 @@ static int fat_sync(FAR struct file *filp)
       DIR_PUTFSTCLUSTHI(direntry, ff->ff_startcluster >> 16);
 
       wrttime = fat_gettime();
-      DIR_PUTWRTTIME(direntry, wrttime);
+      DIR_PUTWRTTIME(direntry, wrttime & 0xffff);
+      DIR_PUTWRTDATE(direntry, wrttime >> 16);
 
       /* Clear the modified bit in the flags */
 
diff --git a/nuttx/fs/fs_fat32.h b/nuttx/fs/fs_fat32.h
index 5687b2b16..9e10cd7d8 100644
--- a/nuttx/fs/fs_fat32.h
+++ b/nuttx/fs/fs_fat32.h
@@ -544,12 +544,16 @@ EXTERN int    fat_hwread(struct fat_mountpt_s *fs, ubyte *buffer,
 EXTERN int    fat_hwwrite(struct fat_mountpt_s *fs, ubyte *buffer,
                           size_t sector, unsigned int nsectors);
 
-/* Cluster access helpers */
+/* Cluster / cluster chain access helpers */
 
 EXTERN ssize_t fat_cluster2sector(struct fat_mountpt_s *fs,  uint32 cluster );
-EXTERN ssize_t fat_getcluster(struct fat_mountpt_s *fs, unsigned int clusterno);
-EXTERN int    fat_putcluster(struct fat_mountpt_s *fs, unsigned int clusterno,
+EXTERN ssize_t fat_getcluster(struct fat_mountpt_s *fs, uint32 clusterno);
+EXTERN int    fat_putcluster(struct fat_mountpt_s *fs, uint32 clusterno,
                              size_t startsector);
+EXTERN int    fat_removechain(struct fat_mountpt_s *fs, uint32 cluster);
+EXTERN sint32 fat_extendchain(struct fat_mountpt_s *fs, uint32 cluster);
+
+#define fat_createchain(fs) fat_extendchain(fs, 0)
 
 /* Help for traverseing directory trees */
 
diff --git a/nuttx/fs/fs_fat32util.c b/nuttx/fs/fs_fat32util.c
index 55378a84b..826d13bec 100644
--- a/nuttx/fs/fs_fat32util.c
+++ b/nuttx/fs/fs_fat32util.c
@@ -4,6 +4,11 @@
  *   Copyright (C) 2007 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
  *
+ * References:
+ *   Microsoft FAT documentation
+ *   FAT implementation 'Copyright (C) 2007, ChaN, all right reserved.'
+ *     which has an unrestricted license.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
@@ -405,6 +410,127 @@ static inline int fat_dirname2path(char *path, struct fat_dirinfo_s *dirinfo)
 }
 
 /****************************************************************************
+ * Name: fat_allocatedirentry
+ *
+ * Desciption: Find a free directory entry
+ *
+ ****************************************************************************/
+
+static int fat_allocatedirentry(struct fat_mountpt_s *fs, struct fat_dirinfo_s *dirinfo)
+{
+  sint32 cluster;
+  size_t sector;
+  ubyte *direntry;
+  ubyte  ch;
+  int    ret;
+  int    i;
+
+  /* Re-initialize directory object */
+
+  cluster = dirinfo->fd_startcluster;
+  if (cluster)
+    {
+     /* Cluster chain can be extended */
+
+      dirinfo->fd_currcluster = cluster;
+      dirinfo->fd_currsector  = fat_cluster2sector(fs, cluster);
+    }
+  else
+    {
+      /* Fixed size FAT12/16 root directory is at fixxed offset/size */
+
+      dirinfo->fd_currsector = fs->fs_rootbase;
+    }
+  dirinfo->fd_index = 0;
+
+  for (;;)
+    {
+      unsigned int dirindex;
+
+      /* Read the directory sector into fs_buffer */
+
+      ret = fat_fscacheread(fs, dirinfo->fd_currsector);
+      if (ret < 0)
+        {
+          return ret;
+        }
+
+      /* Get a pointer to the entry at fd_index */
+
+      dirindex = (dirinfo->fd_index & DIRSEC_NDXMASK(fs)) * 32;
+      direntry = &fs->fs_buffer[dirindex];
+
+      /* Check if this directory entry is empty */
+
+      ch = direntry[DIR_NAME];
+      if (ch == DIR0_ALLEMPTY || ch == DIR0_EMPTY)
+        {
+          /* It is empty -- we have found a directory entry */
+
+          dirinfo->fd_entry = direntry;
+          return OK;
+        }
+
+      ret = fat_nextdirentry(dirinfo);
+      if (ret < 0)
+        {
+          return ret;
+        }
+    }
+
+  /* If we get here, then we have reached the end of the directory table
+   * in this sector without finding a free directory enty.
+   *
+   * It this is a fixed size dirctory entry, then this is an error.
+   * Otherwise, we can try to extend the directory cluster chain to
+   * make space for the new directory entry.
+   */
+
+  if (!cluster)
+    {
+      /* The size is fixed */
+      return -ENOSPC;
+    }
+
+  /* Try to extend the cluster chain for this directory */
+
+  cluster = fat_extendchain(fs, dirinfo->fd_currcluster);
+  if (cluster < 0)
+    {
+      return cluster;
+    }
+
+ /* Flush out any cached date in fs_buffer.. we are going to use
+  * it to initialize the new directory cluster.
+  */
+
+  ret = fat_fscacheflush(fs);
+  if (ret < 0)
+    {
+      return ret;
+    }
+
+  /* Clear all sectors comprising the new directory cluster */
+
+  fs->fs_currentsector = fat_cluster2sector(fs, cluster);
+  memset(fs->fs_buffer, 0, fs->fs_hwsectorsize);
+
+  sector = sector;
+  for (i = fs->fs_fatsecperclus; i; i--)
+    {
+      ret = fat_hwwrite(fs, fs->fs_buffer, sector, 1);
+      if ( ret < 0)
+        {
+          return ret;
+        }
+      sector++;
+    }
+
+  dirinfo->fd_entry = fs->fs_buffer;
+  return OK;
+}
+
+/****************************************************************************
  * Name: fat_checkfsinfo
  *
  * Desciption: Read the FAT32 FSINFO sector
@@ -544,7 +670,6 @@ static int fat_checkbootrecord(struct fat_mountpt_s *fs)
       fs->fs_fsinfo = 0;
       fs->fs_type   = FSTYPE_FAT16;
     }
-
   else if (!notfat32)
     {
       fs->fs_fsinfo   = fs->fs_fatbase + MBR_GETFSINFO(fs->fs_buffer);
@@ -976,133 +1101,136 @@ int fat_hwwrite(struct fat_mountpt_s *fs, ubyte *buffer, size_t sector,
 
 ssize_t fat_cluster2sector(struct fat_mountpt_s *fs,  uint32 cluster )
 {
-    cluster -= 2;
-    if (cluster >= fs->fs_nclusters - 2)
-      {
-         return -EINVAL;
-      }
-    return cluster * fs->fs_fatsecperclus + fs->fs_database;
+  cluster -= 2;
+  if (cluster >= fs->fs_nclusters - 2)
+    {
+       return -EINVAL;
+    }
+  return cluster * fs->fs_fatsecperclus + fs->fs_database;
 }
 
 /****************************************************************************
  * Name: fat_getcluster
  *
- * Desciption: Get the cluster start sector into the FAT
+ * Desciption: Get the cluster start sector into the FAT.
+ *
+ * Return:  <0: error, >=0: sector number
  *
  ****************************************************************************/
 
-ssize_t fat_getcluster(struct fat_mountpt_s *fs, unsigned int clusterno)
+ssize_t fat_getcluster(struct fat_mountpt_s *fs, uint32 clusterno)
 {
-    /* Verify that the cluster number is within range */
+  /* Verify that the cluster number is within range */
 
-    if (clusterno >= 2 && clusterno < fs->fs_nclusters)
+  if (clusterno >= 2 && clusterno < fs->fs_nclusters)
     {
-        /* Okay.. Read the next cluster from the FAT.  The way we will do
-         * this depends on the type of FAT filesystm we are dealing with.
-         */
+      /* Okay.. Read the next cluster from the FAT.  The way we will do
+       * this depends on the type of FAT filesystm we are dealing with.
+       */
 
-        switch (fs->fs_type)
+      switch (fs->fs_type)
         {
-            case FSTYPE_FAT12 :
+          case FSTYPE_FAT12 :
             {
-                size_t       fatsector;
-                unsigned int fatoffset;
-                unsigned int startsector;
-                unsigned int fatindex;
+              size_t       fatsector;
+              unsigned int fatoffset;
+              unsigned int startsector;
+              unsigned int fatindex;
 
-                /* FAT12 is more complex because it has 12-bits (1.5 bytes)
-                 * per FAT entry. Get the offset to the first byte:
-                 */
+              /* FAT12 is more complex because it has 12-bits (1.5 bytes)
+               * per FAT entry. Get the offset to the first byte:
+               */
 
-                fatoffset = (clusterno * 3) / 2;
-                fatsector = fs->fs_fatbase + SEC_NSECTORS(fs, fatoffset);
+              fatoffset = (clusterno * 3) / 2;
+              fatsector = fs->fs_fatbase + SEC_NSECTORS(fs, fatoffset);
 
-                /* Read the sector at this offset */
+              /* Read the sector at this offset */
 
-                if (fat_fscacheread(fs, fatsector) < 0)
+              if (fat_fscacheread(fs, fatsector) < 0)
                 {
-                    /* Read error */
-                    break;
+                  /* Read error */
+                  break;
                 }
 
-                /* Get the first, LS byte of the cluster from the FAT */
+              /* Get the first, LS byte of the cluster from the FAT */
 
-                fatindex    = fatoffset & SEC_NDXMASK(fs);
-                startsector = fs->fs_buffer[fatindex];
+              fatindex    = fatoffset & SEC_NDXMASK(fs);
+              startsector = fs->fs_buffer[fatindex];
 
-                /* With FAT12, the second byte of the cluster number may lie in
-                 * a different sector than the first byte.
-                 */
+              /* With FAT12, the second byte of the cluster number may lie in
+               * a different sector than the first byte.
+               */
 
-                fatindex++;
-                if (fatindex >= fs->fs_hwsectorsize)
+              fatindex++;
+              if (fatindex >= fs->fs_hwsectorsize)
                 {
-                    fatsector++;
-                    fatindex = 0;
+                  fatsector++;
+                  fatindex = 0;
 
-                    if (fat_fscacheread(fs, fatsector) < 0)
+                  if (fat_fscacheread(fs, fatsector) < 0)
                     {
-                        /* Read error */
-                        break;
+                      /* Read error */
+                      break;
                     }
                 }
 
-                /* Get the second, MS byte of the cluster for 16-bits.  The
-                 * does not depend on the endian-ness of the target, but only
-                 * on the fact that the byte stream is little-endian.
-                 */
+              /* Get the second, MS byte of the cluster for 16-bits.  The
+               * does not depend on the endian-ness of the target, but only
+               * on the fact that the byte stream is little-endian.
+               */
 
-                startsector |= (unsigned int)fs->fs_buffer[fatindex] << 8;
+              startsector |= (unsigned int)fs->fs_buffer[fatindex] << 8;
 
-                /* Now, pick out the correct 12 bit cluster start sector value */
+              /* Now, pick out the correct 12 bit cluster start sector value */
 
-                if ((clusterno & 1) != 0)
+              if ((clusterno & 1) != 0)
                 {
-                    /* Odd.. take the MS 12-bits */
-                    startsector >>= 4;
+                  /* Odd.. take the MS 12-bits */
+                  startsector >>= 4;
                 }
-                else
+              else
                 {
-                    /* Even.. take the LS 12-bits */
-                    startsector &= 0x0fff;
+                  /* Even.. take the LS 12-bits */
+                  startsector &= 0x0fff;
                 }
-                return startsector;
+              return startsector;
             }
 
-            case FSTYPE_FAT16 :
+          case FSTYPE_FAT16 :
             {
-                unsigned int fatoffset = 2 * clusterno;
-                size_t       fatsector = fs->fs_fatbase + SEC_NSECTORS(fs, fatoffset);
-                unsigned int fatindex  = fatoffset & SEC_NDXMASK(fs);
+              unsigned int fatoffset = 2 * clusterno;
+              size_t       fatsector = fs->fs_fatbase + SEC_NSECTORS(fs, fatoffset);
+              unsigned int fatindex  = fatoffset & SEC_NDXMASK(fs);
 
-                if (fat_fscacheread(fs, fatsector) < 0)
+              if (fat_fscacheread(fs, fatsector) < 0)
                 {
-                    /* Read error */
-                    break;
+                  /* Read error */
+                  break;
                 }
-                return FAT_GETFAT16(fs->fs_buffer, fatindex);
+              return FAT_GETFAT16(fs->fs_buffer, fatindex);
             }
 
-            case FSTYPE_FAT32 :
+          case FSTYPE_FAT32 :
             {
-                unsigned int fatoffset = 4 * clusterno;
-                size_t       fatsector = fs->fs_fatbase + SEC_NSECTORS(fs, fatoffset);
-                unsigned int fatindex  = fatoffset & SEC_NDXMASK(fs);
+              unsigned int fatoffset = 4 * clusterno;
+              size_t       fatsector = fs->fs_fatbase + SEC_NSECTORS(fs, fatoffset);
+              unsigned int fatindex  = fatoffset & SEC_NDXMASK(fs);
 
-                if (fat_fscacheread(fs, fatsector) < 0)
+              if (fat_fscacheread(fs, fatsector) < 0)
                 {
-                    /* Read error */
-                    break;
+                  /* Read error */
+                  break;
                 }
-                return FAT_GETFAT16(fs->fs_buffer, fatindex) & 0x0fffffff;
+              return FAT_GETFAT16(fs->fs_buffer, fatindex) & 0x0fffffff;
             }
-            default:
-                break;
+          default:
+              break;
         }
     }
 
-    /* There is no cluster information, or an error occured */
-    return (ssize_t)ERROR;
+  /* There is no cluster information, or an error occured */
+
+  return (ssize_t)-EINVAL;
 }
 
 /****************************************************************************
@@ -1112,136 +1240,340 @@ ssize_t fat_getcluster(struct fat_mountpt_s *fs, unsigned int clusterno)
  *
  ****************************************************************************/
 
-int fat_putcluster(struct fat_mountpt_s *fs, unsigned int clusterno, size_t startsector)
+int fat_putcluster(struct fat_mountpt_s *fs, uint32 clusterno, size_t startsector)
 {
-    /* Verify that the cluster number is within range.  Zero erases the cluster. */
+  /* Verify that the cluster number is within range.  Zero erases the cluster. */
 
-    if (clusterno == 0 || (clusterno >= 2 && clusterno < fs->fs_nclusters))
-      {
-        /* Okay.. Write the next cluster into the FAT.  The way we will do
-         * this depends on the type of FAT filesystm we are dealing with.
-         */
+  if (clusterno == 0 || (clusterno >= 2 && clusterno < fs->fs_nclusters))
+    {
+      /* Okay.. Write the next cluster into the FAT.  The way we will do
+       * this depends on the type of FAT filesystm we are dealing with.
+       */
 
-        switch (fs->fs_type)
-          {
-            case FSTYPE_FAT12 :
-              {
-                size_t       fatsector;
-                unsigned int fatoffset;
-                unsigned int fatindex;
-                ubyte        value;
-
-                /* FAT12 is more complex because it has 12-bits (1.5 bytes)
-                 * per FAT entry. Get the offset to the first byte:
-                 */
-
-                fatoffset = (clusterno * 3) / 2;
-                fatsector = fs->fs_fatbase + SEC_NSECTORS(fs, fatoffset);
-
-                /* Make sure that the sector at this offset is in the cache */
-
-                if (fat_fscacheread(fs, fatsector)< 0)
-                  {
-                    /* Read error */
-                    break;
-                  }
-
-                /* Output the LS byte first handling the 12-bit alignment within
-                 * the 16-bits
-                 */
-
-                fatindex = fatoffset & SEC_NDXMASK(fs);
-                if ((clusterno & 1) != 0)
-                  {
-                    value = (fs->fs_buffer[fatindex] & 0x0f) | startsector << 4;
-                  }
-                else
-                  {
-                    value = (ubyte)startsector;
-                  }
-                fs->fs_buffer[fatindex] = value;
-
-                /* With FAT12, the second byte of the cluster number may lie in
-                 * a different sector than the first byte.
-                 */
-
-                fatindex++;
-                if (fatindex >= fs->fs_hwsectorsize)
-                  {
-                    /* Read the next sector */
-
-                    fatsector++;
-                    fatindex = 0;
-
-                    /* Set the dirty flag to make sure the sector that we
-                     * just modified is written out.
-                     */
-
-                    fs->fs_dirty = TRUE;
-                    if (fat_fscacheread(fs, fatsector) < 0)
-                      {
-                        /* Read error */
-                        break;
-                      }
-                  }
-
-                /* Output the MS byte first handling the 12-bit alignment within
-                 * the 16-bits
-                 */
-
-                if ((clusterno & 1) != 0)
-                  {
-                    value = (ubyte)(startsector >> 4);
-                  }
-                else
-                  {
-                    value = (fs->fs_buffer[fatindex] & 0xf0) | (startsector & 0x0f);
-                  }
-                fs->fs_buffer[fatindex] = value;
-              }
-            break;
+      switch (fs->fs_type)
+        {
+          case FSTYPE_FAT12 :
+            {
+              size_t       fatsector;
+              unsigned int fatoffset;
+              unsigned int fatindex;
+              ubyte        value;
 
-            case FSTYPE_FAT16 :
-              {
-                unsigned int fatoffset = 2 * clusterno;
-                size_t       fatsector = fs->fs_fatbase + SEC_NSECTORS(fs, fatoffset);
-                unsigned int fatindex  = fatoffset & SEC_NDXMASK(fs);
-
-                if (fat_fscacheread(fs, fatsector) < 0)
-                  {
-                    /* Read error */
-                    break;
-                  }
-                FAT_PUTFAT16(fs->fs_buffer, fatindex, startsector & 0xffff);
-              }
-            break;
+              /* FAT12 is more complex because it has 12-bits (1.5 bytes)
+               * per FAT entry. Get the offset to the first byte:
+               */
 
-            case FSTYPE_FAT32 :
-              {
-                unsigned int fatoffset = 4 * clusterno;
-                size_t       fatsector = fs->fs_fatbase + SEC_NSECTORS(fs, fatoffset);
-                unsigned int fatindex  = fatoffset & SEC_NDXMASK(fs);
-
-                if (fat_fscacheread(fs, fatsector) < 0)
-                  {
-                    /* Read error */
-                    break;
-                  }
-                FAT_PUTFAT32(fs->fs_buffer, fatindex, startsector & 0x0fffffff);
-              }
-            break;
+              fatoffset = (clusterno * 3) / 2;
+              fatsector = fs->fs_fatbase + SEC_NSECTORS(fs, fatoffset);
 
-            default:
-                return ERROR;
-          }
+              /* Make sure that the sector at this offset is in the cache */
 
-        /* Mark the modified sector as "dirty" and return success */
+              if (fat_fscacheread(fs, fatsector)< 0)
+                {
+                  /* Read error */
+                  break;
+                }
 
-        fs->fs_dirty = 1;
-        return OK;
-      }
-    return ERROR;
- }
+              /* Output the LS byte first handling the 12-bit alignment within
+               * the 16-bits
+               */
+
+              fatindex = fatoffset & SEC_NDXMASK(fs);
+              if ((clusterno & 1) != 0)
+                {
+                  value = (fs->fs_buffer[fatindex] & 0x0f) | startsector << 4;
+                }
+              else
+                {
+                  value = (ubyte)startsector;
+                }
+              fs->fs_buffer[fatindex] = value;
+
+              /* With FAT12, the second byte of the cluster number may lie in
+               * a different sector than the first byte.
+               */
+
+              fatindex++;
+              if (fatindex >= fs->fs_hwsectorsize)
+                {
+                  /* Read the next sector */
+
+                  fatsector++;
+                  fatindex = 0;
+
+                  /* Set the dirty flag to make sure the sector that we
+                   * just modified is written out.
+                   */
+
+                  fs->fs_dirty = TRUE;
+                  if (fat_fscacheread(fs, fatsector) < 0)
+                    {
+                      /* Read error */
+                      break;
+                    }
+                }
+
+              /* Output the MS byte first handling the 12-bit alignment within
+               * the 16-bits
+               */
+
+              if ((clusterno & 1) != 0)
+                {
+                  value = (ubyte)(startsector >> 4);
+                }
+              else
+                {
+                  value = (fs->fs_buffer[fatindex] & 0xf0) | (startsector & 0x0f);
+                }
+              fs->fs_buffer[fatindex] = value;
+            }
+          break;
+
+          case FSTYPE_FAT16 :
+            {
+              unsigned int fatoffset = 2 * clusterno;
+              size_t       fatsector = fs->fs_fatbase + SEC_NSECTORS(fs, fatoffset);
+              unsigned int fatindex  = fatoffset & SEC_NDXMASK(fs);
+
+              if (fat_fscacheread(fs, fatsector) < 0)
+                {
+                  /* Read error */
+                  break;
+                }
+              FAT_PUTFAT16(fs->fs_buffer, fatindex, startsector & 0xffff);
+            }
+          break;
+
+          case FSTYPE_FAT32 :
+            {
+              unsigned int fatoffset = 4 * clusterno;
+              size_t       fatsector = fs->fs_fatbase + SEC_NSECTORS(fs, fatoffset);
+              unsigned int fatindex  = fatoffset & SEC_NDXMASK(fs);
+
+              if (fat_fscacheread(fs, fatsector) < 0)
+                {
+                  /* Read error */
+                  break;
+                }
+              FAT_PUTFAT32(fs->fs_buffer, fatindex, startsector & 0x0fffffff);
+            }
+          break;
+
+          default:
+              return -EINVAL;
+        }
+
+      /* Mark the modified sector as "dirty" and return success */
+
+      fs->fs_dirty = 1;
+      return OK;
+    }
+
+  return -EINVAL;
+}
+
+/****************************************************************************
+ * Name: fat_removechain
+ *
+ * Desciption: Remove an entire chain of clusters, starting with 'cluster'
+ *
+ ****************************************************************************/
+
+int fat_removechain(struct fat_mountpt_s *fs, uint32 cluster)
+{
+  sint32 nextcluster;
+  int    ret;
+
+  /* Loop while there are clusters in the chain */
+
+  while (cluster >= 2 && cluster < fs->fs_nclusters)
+    {
+      /* Get the next cluster after the current one */
+
+      nextcluster = fat_getcluster(fs, cluster);
+      if (nextcluster < 0)
+        {
+          /* Error! */
+          return nextcluster;
+        }
+
+      /* Then nullify current cluster -- removing it from the chain */
+
+      ret = fat_putcluster(fs, cluster, 0);
+      if (ret < 0)
+        {
+          return ret;
+        }
+
+      /* Update FSINFINFO data */
+
+      if (fs->fs_fsifreecount != 0xffffffff)
+        {
+          fs->fs_fsifreecount++;
+          fs->fs_fsidirty = 1;
+        }
+
+      /* Then set up to remove the next cluster */
+
+      cluster = nextcluster;
+  }
+
+  return OK;
+}
+
+/****************************************************************************
+ * Name: fat_extendchain
+ *
+ * Desciption: Add a new cluster to the chain following cluster (if cluster
+ *   is non-NULL).  if cluster is zero, then a new chain is created.
+ *
+ * Return: <0:error, 0: no free cluster, >=2: new cluster number
+ *
+ ****************************************************************************/
+
+sint32 fat_extendchain(struct fat_mountpt_s *fs, uint32 cluster)
+{
+  ssize_t startsector;
+  uint32  newcluster;
+  uint32  startcluster;
+  int     ret;
+
+  /* The special value 0 is used when the new chain should start */
+
+  if (cluster == 0)
+    {
+      /* The FSINFO NextFree entry should be a good starting point
+       * in the search for a new cluster
+       */
+
+      startcluster = fs->fs_fsinextfree;
+      if (startcluster == 0 || startcluster >= fs->fs_nclusters)
+        {
+          /* But it is bad.. we have to start at the beginning */
+          startcluster = 1;
+        }
+    }
+  else
+    {
+      /* We are extending an existing chain. Verify that this
+       * is a valid cluster by examining its start sector.
+       */
+
+      startsector = fat_getcluster(fs, cluster);
+      if (startsector < 0)
+        {
+          /* An error occurred, return the error value */
+          return startsector;
+        }
+      else if (startsector < 2)
+        {
+          /* Oops.. this cluster does not exist. */
+          return 0;
+        }
+      else if (startsector < fs->fs_nclusters)
+        {
+          /* It is already followed by next cluster */
+          return startsector;
+        }
+
+      /* Okay.. it checks out */
+
+      startcluster = cluster;
+    }
+
+  /* Loop until (1) we discover that there are not free clusters
+   * (return 0), an errors occurs (return -errno), or (3) we find
+   * the next cluster (return the new cluster number).
+   */
+
+  newcluster = startcluster;
+  for (;;)
+    {
+      /* Examine the next cluster in the FAT */
+
+      newcluster++;
+      if (newcluster >= fs->fs_nclusters)
+        {
+          /* If we hit the end of the available clusters, then
+           * wrap back to the beginning because we might have
+           * started at a non-optimal place.  But don't continue
+           * past the start cluster.
+           */
+
+          newcluster = 2;
+          if (newcluster > startcluster)
+            {
+              /* We are back past the starting cluster, then there
+               * is no free cluster.
+               */
+
+              return 0;
+            }
+        }
+
+      /* We have a candidate cluster.  Check if the cluster number is
+       * mapped to a group of sectors.
+       */
+
+      startsector = fat_getcluster(fs, newcluster);
+      if (startsector == 0)
+        {
+          /* Found have found a free cluster break out*/
+          break;
+        }
+      else if (startsector < 0)
+        {
+          /* Some error occurred, return the error number */
+          return startsector;
+        }
+
+      /* We wrap all the back to the starting cluster?  If so, then
+       * there are no free clusters.
+       */
+
+      if (newcluster == startcluster)
+        {
+          return 0;
+        }
+    }
+
+  /* We get here only if we break out with an available cluster
+   * number in 'newcluster'  Now mark that cluster as in-use.
+   */
+
+  ret = fat_putcluster(fs, newcluster, 0x0fffffff);
+  if (ret < 0)
+    {
+      /* An error occurred */ 
+      return ret;
+    }
+
+  /* And link if to the start cluster (if any)*/
+
+  if (cluster)
+    {
+      /* There is a start cluster -- link it */
+
+      ret = fat_putcluster(fs, cluster, newcluster);
+      if (ret < 0)
+        {
+          return ret;
+        }
+    }
+
+  /* And update the FINSINFO for the next time we have to search */
+
+  fs->fs_fsinextfree = newcluster;
+  if (fs->fs_fsifreecount != 0xffffffff)
+    {
+      fs->fs_fsifreecount--;
+      fs->fs_fsidirty = 1;
+    }
+
+  /* Return then number of the new cluster that was added to the chain */
+
+  return newcluster;
+}
 
 /****************************************************************************
  * Name: fat_nextdirentry
@@ -1497,12 +1829,61 @@ int fat_finddirentry(struct fat_dirinfo_s *dirinfo, const char *path)
  *
  * Desciption: Truncate an existing file to zero length
  *
+ * Assumptions:  The caller holds mountpoint semaphore, fs_buffer holds
+ *   the directory entry, dirinfo refers to the current fs_buffer content.
+ *
  ****************************************************************************/
 
 int  fat_dirtruncate(struct fat_mountpt_s *fs, struct fat_dirinfo_s *dirinfo)
 {
-#warning "File truncation logic not implemented"
-  return -ENOSYS;
+  unsigned int startcluster;
+  uint32       writetime;
+  size_t       savesector;
+  int          ret;
+
+  /* Get start cluster of the file to truncate */
+
+  startcluster =
+      ((uint32)DIR_GETFSTCLUSTHI(dirinfo->fd_entry) << 16) |
+      DIR_GETFSTCLUSTLO(dirinfo->fd_entry);
+
+  /* Clear the cluster start value in the directory and set the file size
+   * to zero.  This makes the file look empty but also have to dispose of
+   * all of the clusters in the chain.
+   */
+
+  DIR_PUTFSTCLUSTHI(dirinfo->fd_entry, 0);
+  DIR_PUTFSTCLUSTLO(dirinfo->fd_entry, 0);
+  DIR_PUTFILESIZE(dirinfo->fd_entry, 0);
+
+  /* Set the ARCHIVE attribute and update the write time */
+
+  DIR_PUTATTRIBUTES(dirinfo->fd_entry, FATATTR_ARCHIVE);
+ 
+  writetime = fat_gettime();
+  DIR_PUTWRTTIME(dirinfo->fd_entry, writetime & 0xffff);
+  DIR_PUTWRTDATE(dirinfo->fd_entry, writetime > 16);
+
+  /* This sector needs to be written back to disk eventually */
+
+  fs->fs_dirty = TRUE;
+
+  /* Now remove the entire cluster chain comprising the file */
+
+  savesector = fs->fs_currentsector;
+  ret = fat_removechain(fs, startcluster);
+  if (ret < 0)
+  {
+    return ret;
+  }
+
+  /* Setup FSINFO to resuse this cluster next */
+
+  fs->fs_fsinextfree = startcluster - 1;
+
+  /* Make sure that the directory is still in the cache */
+
+  return fat_fscacheread(fs, savesector);
 }
 
 /****************************************************************************
@@ -1514,8 +1895,44 @@ int  fat_dirtruncate(struct fat_mountpt_s *fs, struct fat_dirinfo_s *dirinfo)
 
 int fat_dircreate(struct fat_mountpt_s *fs, struct fat_dirinfo_s *dirinfo)
 {
-#warning "File truncation logic not implemented"
-  return -ENOSYS;
+  ubyte  *direntry;
+  uint32  time;
+  int     ret;
+
+  /* Set up the directory entry */
+
+  ret = fat_allocatedirentry(fs, dirinfo);
+  if (ret != OK)
+    {
+      /* Failed to set up directory entry */
+      return ret;
+    }
+
+  /* Initialize the 32-byte directory entry */
+
+  direntry = dirinfo->fd_entry;
+  memset(direntry, 0, 32);
+
+  /* Directory name info */
+
+  memcpy(&direntry[DIR_NAME], dirinfo->fd_name, 8+3);
+#ifdef CONFIG_FLAT_LCNAMES
+  DIR_PUTNTRES(dirinfo->fd_entry, dirinfo->fd_ntflags);
+#else
+  DIR_PUTNTRES(dirinfo->fd_entry, 0);
+#endif
+
+  /* ARCHIVE attribute, write time, creation time */
+  DIR_PUTATTRIBUTES(dirinfo->fd_entry, FATATTR_ARCHIVE);
+ 
+  time = fat_gettime();
+  DIR_PUTWRTTIME(dirinfo->fd_entry, time & 0xffff);
+  DIR_PUTCRTIME(dirinfo->fd_entry, time & 0xffff);
+  DIR_PUTWRTDATE(dirinfo->fd_entry, time >> 16);
+  DIR_PUTCRDATE(dirinfo->fd_entry, time >> 16);
+
+  fs->fs_dirty = TRUE;
+  return OK;
 }
 
 /****************************************************************************