NFS client FS update

git-svn-id: https://nuttx.svn.sourceforge.net/svnroot/nuttx/trunk@4622 7fd9a85b-ad96-42d3-883c-3090e2eb8679
2026-10-31 22:11:37 +08:00 · 2012-04-16 23:01:21 +00:00
parent eaf671937f
commit 82474eadeb
8 changed files with 942 additions and 1553 deletions
@@ -42,7 +42,7 @@ CSRCS +=
 # Files required for NFS RPC
 ASRCS +=
-CSRCS += rpc_clnt.c nfs_socket.c
+CSRCS += rpc_clnt.c nfs_socket.c nfs_util.c nfs_vfsops.c
 # Argument for dependency checking
@@ -270,11 +270,6 @@ struct nfsstats
 * by them and break.
 */
 struct uio;
 struct buf;
 struct vattr;
 struct nameidata;               /* XXX */
 /* Nfs outstanding request list element */
 struct nfsreq
@@ -338,114 +333,6 @@ struct nfsrv_descript
  uint32_t nd_retxid;         /* Reply xid */
 };
 /* NFS procedures args */
 struct wcc_attr
 {
  nfsuint64   size;
  nfstime3    mtime;
  nfstime3    ctime;
 }
 struct wcc_data
 {
  wcc_attr    before;
  nfs_fattr   after;
 };
 struct diropargs3
 {
  nfsfh_t     dir;
  const char  name;
 };
 struct CREATE3args
 {
  diropargs3  where;
  nfsv3_sattr how;
 };
 struct CREATE3resok
 {
  const char  handle;
  nfs_fattr   attributes;
  wcc_data    dir_wcc;
 };
 struct READ3args
 {
  nfstype     file;
  uint64_t    offset;
  uint32_t    count;
 };
 struct READ3resok
 {
  nfs_fattr   file_attributes;
  uint32_t    count;
  bool        eof;
  const char  data;
 };
 enum stable_how
 {
  UNSTABLE  = 0,
  DATA_SYNC = 1,
  FILE_SYNC = 2
 };
 struct WRITE3args
 {
  nfstype     file;
  uint64_t    offset;
  uint32_t    count;
  stable_how  stable;
  const char  data;
 };
 struct WRITE3resok
 {
  wcc_data    file_wcc;
  count3      count;
  stable_how  committed;
  unsigned char verf;
 };
 struct REMOVE3args
 {
  diropargs3  object;
 };
 struct REMOVE3resok
 {
  wcc_data    dir_wcc;
 };
 struct RENAME3args
 {
  diropargs3  from;
  diropargs3  to;
 };
 struct RENAME3resok
 {
  wcc_data    fromdir_wcc;
  wcc_data    todir_wcc;
 };
 struct MKDIR3args
 {
  diropargs3  where;
  nfsv3_sattr attributes;
 };
 struct MKDIR3resok
 {
  const char  handle;
  nfs_fattr   obj_attributes;
  wcc_data    dir_wcc;
 };
 /****************************************************************************
 * Public Data
 ****************************************************************************/
@@ -75,7 +75,7 @@ struct nfsmount
  int nm_numgrps;             /* Max. size of groupslist */
  nfsfh_t nm_fh;              /* File handle of root dir */
  int nm_fhsize;              /* Size of root file handle */
-  struct rpcclnt nm_rpcclnt;  /* rpc state */
+  struct rpcclnt *nm_rpcclnt; /* rpc state */
  struct socket *nm_so;       /* Rpc socket */
  int nm_sotype;              /* Type of socket */
  int nm_soproto;             /* and protocol */
@@ -99,24 +99,7 @@ struct nfsmount
  int nm_acregmax;            /* Reg file attr cache max lifetime */
  unsigned char nm_verf[NFSX_V3WRITEVERF]; /* V3 write verifier */
 //char nm_mntonname[90];      /* directory on which mounted */
-  uint8_t *nm_buffer;         /* This is an allocated buffer to hold one sector*/
+//uint8_t *nm_buffer;         /* This is an allocated buffer to hold one sector*/
 };
 /****************************************************************************
 * Public Function Prototypes
 ****************************************************************************/
 /* Prototypes for NFS mount operations: */
 int nfs_mount(struct inode *, const char *, void *);
 int mountnfs(struct nfs_args *, struct inode *, char *, char *);
 void nfs_decode_args(struct nfsmount *, struct nfs_args *, struct nfs_args *);
 int nfs_unmount(struct inode *, int);
 int nfs_root(struct inode *, struct file **);
 int nfs_statfs(struct inode *, struct statfs *);
 int nfs_sync(struct inode *, int);
 int nfs_vget(struct inode *, ino_t, struct file **);
 int nfs_fsinfo(struct nfsmount *, struct file *);
 void nfs_init(void);
 #endif
@@ -430,6 +430,7 @@ struct nfsv3_sattr
 struct nfs_statfs
 {
  struct nfs_fattr obj_attributes;
  union
  {
    struct
@@ -468,6 +469,7 @@ struct nfs_statfs
 struct nfsv3_fsinfo
 {
  struct nfs_fattr obj_attributes;
  uint32_t fs_rtmax;
  uint32_t fs_rtpref;
  uint32_t fs_rtmult;
@@ -480,14 +482,161 @@ struct nfsv3_fsinfo
  uint32_t fs_properties;
 };
-struct nfsv3_pathconf
+/* NFS procedures args */
 struct wcc_attr
 {
-  uint32_t pc_linkmax;
+  nfsuint64 size;
-  uint32_t pc_namemax;
+  nfstime3 mtime;
-  uint32_t pc_notrunc;
+  nfstime3 ctime;
-  uint32_t pc_chownrestricted;
+};
-  uint32_t pc_caseinsensitive;
+
-  uint32_t pc_casepreserving;
+struct wcc_data
 {
  struct wcc_attr     before;
  struct nfs_fattr    after;
 };
 struct diropargs3
 {
  nfsfh_t            dir;
  const char         name;
 };
 struct CREATE3args
 {
  struct diropargs3  where;
  struct nfsv3_sattr how;
 };
 struct CREATE3resok
 {
  nfsfh_t            handle;
  struct nfs_fattr   attributes;
  struct wcc_data    dir_wcc;
 };
 struct READ3args
 {
  nfstype            file;
  uint64_t           offset;
  uint32_t           count;
 };
 struct READ3resok
 {
  struct nfs_fattr   file_attributes;
  uint32_t           count;
  bool               eof;
  const char         data;
 };
 enum stable_how
 {
  UNSTABLE  = 0,
  DATA_SYNC = 1,
  FILE_SYNC = 2
 };
 struct WRITE3args
 {
  nfstype            file;
  uint64_t           offset;
  uint32_t           count;
  enum stable_how    stable;
  const char         data;
 };
 struct WRITE3resok
 {
  struct wcc_data    file_wcc;
  uint32_t           count;
  enum stable_how    committed;
  unsigned char      verf;
 };
 struct REMOVE3args
 {
  struct diropargs3  object;
 };
 struct REMOVE3resok
 {
  struct wcc_data    dir_wcc;
 };
 struct RENAME3args
 {
  struct diropargs3  from;
  struct diropargs3  to;
 };
 struct RENAME3resok
 {
  struct wcc_data    fromdir_wcc;
  struct wcc_data    todir_wcc;
 };
 struct MKDIR3args
 {
  struct diropargs3  where;
  struct nfsv3_sattr attributes;
 };
 struct MKDIR3resok
 {
  nfsfh_t            handle;
  struct nfs_fattr   obj_attributes;
  struct wcc_data    dir_wcc;
 };
 struct RMDIR3args 
 {
  struct diropargs3  object;
 };
 struct RMDIR3resok 
 {
  struct wcc_data    dir_wcc;
 };
 struct READDIR3args 
 {
  nfsfh_t            dir;
  nfsuint64          cookie;
  nfsuint64          cookieverf;
  uint32_t           count;
 };
 struct entry3 
 {
  uint64_t           fileid;
  unsigned char      name;
  nfsuint64          cookie;
  struct entry3     *nextentry;
 };
 struct dirlist3 
 {
  struct entry3     *entries;
  bool eof;
 };
 struct READDIR3resok 
 {
  struct nfs_fattr   dir_attributes;
  nfsuint64          cookieverf;
  struct dirlist3    reply;
 };
 struct FSINFOargs
 {
  nfsfh_t            fsroot;
 };
 struct FSSTAT3args
 {
  nfsfh_t            fsroot;
 };
 #endif
@@ -163,7 +163,7 @@ void nfsx_safedisconnect(struct nfsmount *nmp)
 }
 #endif
-int nfsx_request_xx(struct nfsmount *nm, int procnum,void *datain, void *dataout)
+int nfsx_request_xx(struct nfsmount *nm, int procnum, void *datain, void *dataout)
 {
  int error;
  struct nfsmount *nmp;
@@ -39,8 +39,10 @@
 #include <nuttx/config.h>
 #include <sys/types.h>
 #include <sys/time.h>
 #include <stdint.h>
 #include <queue.h>
 #include <stdbool.h>
 #include <stdlib.h>
 #include <string.h>
@@ -49,10 +51,11 @@
 #include <assert.h>
 #include <debug.h>
 #include <nuttx/fs/ioctl.h>
 #include <nuttx/fs/dirent.h>
-#include "nfsmount.h"
+#include "nfs_proto.h"
 #include "nfs_mount.h"
 #include "nfs_node.h"
 /****************************************************************************
 * Private Types
@@ -74,199 +77,6 @@
 * Private Functions
 ****************************************************************************/
 /****************************************************************************
 * Name: nfs_checkentry
 *
 * Desciption:
 *   Check if the entry at offset is a directory or file path segment
 *
 ****************************************************************************/
 static inline int nfs_checkentry(struct nfs_mountpt_s *rm, uint32_t offset,
                                 const char *entryname, int entrylen,
                                 struct nfs_dirinfo_s *dirinfo)
 {
  char name[NAME_MAX+1];
  uint32_t linkoffset;
  uint32_t next;
  uint32_t info;
  uint32_t size;
  int ret;
  /* Parse the directory entry at this offset (which may be re-directed
   * to some other entry if HARLINKED).
   */
  ret = nfs_parsedirentry(rm, offset, &linkoffset, &next, &info, &size);
  if (ret < 0)
    {
      return ret;
    }
  /* Now we are pointing to the real entry of interest. Is it a
   * directory? Or a file?
   */
  if (IS_DIRECTORY(next) || IS_FILE(next))
    {
      /* Get the name of the directory entry. */
      ret = nfs_parsefilename(rm, offset, name);
      if (ret < 0)
        {
          return ret;
        }
      /* Then check if this the name segment we are looking for.  The
       * string comparison is awkward because there is no terminator
       * on entryname (there is a terminator on name, however)
       */
      if (memcmp(entryname, name, entrylen) == 0 &&
          strlen(name) == entrylen)
        {
          /* Found it -- save the component info and return success */
          if (IS_DIRECTORY(next))
            {
              dirinfo->rd_dir.fr_firstoffset = info;
              dirinfo->rd_dir.fr_curroffset  = info;
              dirinfo->rd_size               = 0;
            }
          else
            {
              dirinfo->rd_dir.fr_curroffset  = offset;
              dirinfo->rd_size               = size;
            }
          dirinfo->rd_next                   = next;
          return OK;
        }
    }
  /* The entry is not a directory or it does not have the matching name */
  return -ENOENT;
 }
 /****************************************************************************
 * Name: nfs_devcacheread
 *
 * Desciption:
 *   Read the specified sector for specified offset into the sector cache.
 *   Return the index into the sector corresponding to the offset
 *
 ****************************************************************************/
 int16_t nfs_devcacheread(struct nfs_mountpt_s *rm, uint32_t offset)
 {
  uint32_t sector;
  int      ret;
  /* rm->rm_cachesector holds the current sector that is buffer in or referenced
   * by rm->tm_buffer. If the requested sector is the same as this sector,
   * then we do nothing.
   */
  sector = SEC_NSECTORS(rm, offset);
  if (rm->rm_cachesector != sector)
    {
      /* Check the access mode */
      if (rm->rm_xipbase)
        {
          /* In XIP mode, rf_buffer is just an offset pointer into the device
           * address space.
           */
          rm->rm_buffer = rm->rm_xipbase + SEC_ALIGN(rm, offset);
        }
      else
        {
          /* In non-XIP mode, we will have to read the new sector.*/
          ret = nfs_hwread(rm, rm->rm_buffer, sector, 1);
          if (ret < 0)
            {
               return (int16_t)ret;
            }
        }
      /* Update the cached sector number */
      rm->rm_cachesector = sector;
    }
  /* Return the offset */
  return offset & SEC_NDXMASK(rm);
 }
 /****************************************************************************
 * Name: nfs_searchdir
 *
 * Desciption:
 *   This is part of the nfs_finddirentry log.  Search the directory
 *   beginning at dirinfo->fr_firstoffset for entryname.
 *
 ****************************************************************************/
 static inline int nfs_searchdir(struct nfs_mountpt_s *rm,
                                const char *entryname, int entrylen,
                                struct nfs_dirinfo_s *dirinfo)
 {
  uint32_t offset;
  uint32_t next;
  int16_t  ndx;
  int      ret;
  /* Then loop through the current directory until the directory
   * with the matching name is found.  Or until all of the entries
   * the directory have been examined.
   */
  offset = dirinfo->rd_dir.fr_firstoffset;
  do
    {
      /* Read the sector into memory (do this before calling
       * nfs_checkentry() so we won't have to read the sector
       * twice in the event that the offset refers to a hardlink).
       */
      ndx = nfs_devcacheread(rm, offset);
      if (ndx < 0)
        {
          return ndx;
        }
      /* Because everything is chunked and aligned to 16-bit boundaries,
       * we know that most the basic node info fits into the sector.
       */
      next = nfs_devread32(rm, ndx + ROMFS_FHDR_NEXT) & RFNEXT_OFFSETMASK;
      /* Check if the name this entry is a directory with the matching
       * name
       */
      ret = nfs_checkentry(rm, offset, entryname, entrylen, dirinfo);
      if (ret == OK)
        {
           /* Its a match! Return success */
           return OK;
        }
      /* No match... select the offset to the next entry */
      offset = next;
    }
   while (next != 0);
   /* There is nothing in this directoy with that name */
   return -ENOENT;
 }
 /****************************************************************************
 * Public Functions
 ****************************************************************************/
@@ -298,223 +108,6 @@ void nfs_semgive(struct nfsmount *nmp)
   sem_post(&nmp->nm_sem);
 }
 /****************************************************************************
 * Name: nfs_hwread
 *
 * Desciption: Read the specified sector into the sector buffer
 *
 ****************************************************************************/
 int nfs_hwread(struct nfs_mountpt_s *rm, uint8_t *buffer, uint32_t sector,
               unsigned int nsectors)
 {
  int ret = -ENODEV;
  /* Check the access mode */
  if (rm->rm_xipbase)
    {
      /* In XIP mode, we just copy the requested data */
      memcpy(buffer,
             rm->rm_xipbase + sector*rm->rm_hwsectorsize,
             nsectors*rm->rm_hwsectorsize);
      ret = OK;
    }
  else
    {
      /* In non-XIP mode, we have to read the data from the device */
      struct inode *inode = rm->rm_blkdriver;
      ssize_t nsectorsread;
      DEBUGASSERT(inode);
      if (inode->u.i_bops && inode->u.i_bops->read)
        {
          nsectorsread =
            inode->u.i_bops->read(inode, buffer, sector, nsectors);
          if (nsectorsread == (ssize_t)nsectors)
            {
              ret = OK;
            }
          else if (nsectorsread < 0)
            {
              ret = nsectorsread;
            }
        }
    }
  return ret;
 }
 /****************************************************************************
 * Name: nfs_filecacheread
 *
 * Desciption:
 *   Read the specified sector into the sector cache
 *
 ****************************************************************************/
 int nfs_filecacheread(struct nfs_mountpt_s *rm, struct nfs_file_s *rf, uint32_t sector)
 {
  int ret;
  fvdbg("sector: %d cached: %d sectorsize: %d XIP base: %p buffer: %p\n",
        sector, rf->rf_cachesector, rm->rm_hwsectorsize,
        rm->rm_xipbase, rf->rf_buffer);
  /* rf->rf_cachesector holds the current sector that is buffer in or referenced
   * by rf->rf_buffer. If the requested sector is the same as this sector,
   * then we do nothing.
   */
  if (rf->rf_cachesector != sector)
    {
      /* Check the access mode */
      if (rm->rm_xipbase)
        {
          /* In XIP mode, rf_buffer is just an offset pointer into the device
           * address space.
           */
          rf->rf_buffer = rm->rm_xipbase + sector * rm->rm_hwsectorsize;
          fvdbg("XIP buffer: %p\n", rf->rf_buffer);
        }
      else
        {
          /* In non-XIP mode, we will have to read the new sector.*/
          fvdbg("Calling nfs_hwread\n");
          ret = nfs_hwread(rm, rf->rf_buffer, sector, 1);
          if (ret < 0)
            {
              fdbg("nfs_hwread failed: %d\n", ret);
              return ret;
            }
        }
      /* Update the cached sector number */
      rf->rf_cachesector = sector;
    }
  return OK;
 }
 /****************************************************************************
 * Name: nfs_hwconfigure
 *
 * Desciption:
 *   This function is called as part of the ROMFS mount operation   It
 *   configures the ROMFS filestem for use on this block driver.  This includes
 *   the accounting for the geometry of the device, setting up any XIP modes
 *   of operation, and/or allocating any cache buffers.
 *
 ****************************************************************************/
 int nfs_hwconfigure(struct nfs_mountpt_s *rm)
 {
  struct inode *inode = rm->rm_blkdriver;
  struct geometry geo;
  int ret;
  /* Get the underlying device geometry */
 #ifdef CONFIG_DEBUG
  if (!inode || !inode->u.i_bops || !inode->u.i_bops->geometry)
    {
      return -ENODEV;
    }
 #endif
  ret = inode->u.i_bops->geometry(inode, &geo);
  if (ret != OK)
    {
      return ret;
    }
  if (!geo.geo_available)
    {
      return -EBUSY;
    }
  /* Save that information in the mount structure */
  rm->rm_hwsectorsize = geo.geo_sectorsize;
  rm->rm_hwnsectors   = geo.geo_nsectors;
  /* Determine if block driver supports the XIP mode of operation */
  rm->rm_cachesector  = (uint32_t)-1;
  if (inode->u.i_bops->ioctl)
    {
      ret = inode->u.i_bops->ioctl(inode, BIOC_XIPBASE,
                                   (unsigned long)&rm->rm_xipbase);
      if (ret == OK && rm->rm_xipbase)
        {
          /* Yes.. Then we will directly access the media (vs.
           * copying into an allocated sector buffer.
           */
          rm->rm_buffer      = rm->rm_xipbase;
          rm->rm_cachesector = 0;
          return OK;
        }
    }
  /* Allocate the device cache buffer for normal sector accesses */
  rm->rm_buffer = (uint8_t*)malloc(rm->rm_hwsectorsize);
  if (!rm->rm_buffer)
    {
      return -ENOMEM;
    }
  return OK;
 }
 /****************************************************************************
 * Name: nfs_ffileconfigure
 *
 * Desciption:
 *   This function is called as part of the ROMFS file open operation   It
 *   sets up the file structure to handle buffer appropriately, depending
 *   upon XIP mode or not.
 *
 ****************************************************************************/
 int nfs_fileconfigure(struct nfs_mountpt_s *rm, struct nfs_file_s *rf)
 {
  /* Check if XIP access mode is supported.  If so, then we do not need
   * to allocate anything.
   */
  if (rm->rm_xipbase)
    {
      /* We'll put a valid address in rf_buffer just in case. */
      rf->rf_cachesector = 0;
      rf->rf_buffer      = rm->rm_xipbase;
    }
  else
    {
      /* Nothing in the cache buffer */
      rf->rf_cachesector = (uint32_t)-1;
      /* Create a file buffer to support partial sector accesses */
      rf->rf_buffer = (uint8_t*)malloc(rm->rm_hwsectorsize);
      if (!rf->rf_buffer)
        {
          return -ENOMEM;
        }
    }
  return OK;
 }
 /****************************************************************************
 * Name: nfs_checkmount
 *
@@ -536,7 +129,7 @@ int nfs_checkmount(struct nfsmount *nmp)
   */
  DEBUGASSERT(nmp && nmp->nm_blkdriver);
-  if (nmp->mm_mounted)
+  if (nmp->nm_mounted)
    {
      /* We still think the mount is healthy.  Check an see if this is
       * still the case
@@ -566,277 +159,3 @@ int nfs_checkmount(struct nfsmount *nmp)
  return -ENODEV;
 }
 /****************************************************************************
 * Name: nfs_finddirentry
 *
 * Desciption:
 *   Given a path to something that may or may not be in the file system,
 *   return the directory entry of the item.
 *
 ****************************************************************************/
 int nfs_finddirentry(struct nfs_mountpt_s *rm, struct nfs_dirinfo_s *dirinfo,
                     const char *path)
 {
  const char *entryname;
  const char *terminator;
  int entrylen;
  int ret;
  /* Start with the first element after the root directory */
  dirinfo->rd_dir.fr_firstoffset = rm->rm_rootoffset;
  dirinfo->rd_dir.fr_curroffset  = rm->rm_rootoffset;
  dirinfo->rd_next               = RFNEXT_DIRECTORY;
  dirinfo->rd_size               = 0;
  /* The root directory is a special case */
  if (!path || path[0] == '\0')
    {
      return OK;
    }
  /* Then loop for each directory/file component in the full path */
  entryname    = path;
  terminator = NULL;
  for (;;)
    {
      /* Find the start of the next path component */
      while (*entryname == '/') entryname++;
      /* Find the end of the next path component */
      terminator = strchr(entryname, '/');
      if (!terminator)
        {
          entrylen = strlen(entryname);
        }
      else
        {
          entrylen = terminator - entryname;
        }
      /* Long path segment names will be truncated to NAME_MAX */
      if (entrylen > NAME_MAX)
        {
          entrylen = NAME_MAX;
        }
      /* Then find the entry in the current directory with the
       * matching name.
       */
      ret = nfs_searchdir(rm, entryname, entrylen, dirinfo);
      if (ret < 0)
        {
          return ret;
        }
      /* Was that the last path component? */
      if (!terminator)
        {
           /* Yes.. return success */
           return OK;
        }
      /* No... If that was not the last path component, then it had
       * better have been a directory
       */
      if (!IS_DIRECTORY(dirinfo->rd_next))
        {
          return -ENOTDIR;
        }
      /* Setup to search the next directory for the next component
       * of the path
       */
      entryname = terminator;
    }
  return ERROR; /* Won't get here */
 }
 /****************************************************************************
 * Name: nfs_parsedirentry
 *
 * Desciption:
 *   Return the directory entry at this offset.  If rf is NULL, then the
 *   mount device resources are used.  Otherwise, file resources are used.
 *
 ****************************************************************************/
 int nfs_parsedirentry(struct nfs_mountpt_s *rm, uint32_t offset, uint32_t *poffset,
                      uint32_t *pnext, uint32_t *pinfo, uint32_t *psize)
 {
  uint32_t save;
  uint32_t next;
  int16_t  ndx;
  int      ret;
  /* Read the sector into memory */
  ndx = nfs_devcacheread(rm, offset);
  if (ndx < 0)
    {
      return ndx;
    }
  /* Yes.. Save the first 'next' value.  That has the offset needed to
   * traverse the parent directory.  But we may need to change the type
   * after we follow the hard links.
   */
  save = nfs_devread32(rm, ndx + ROMFS_FHDR_NEXT);
  /* Traverse hardlinks as necesssary to get to the real file header */
  ret = nfs_followhardlinks(rm, offset, poffset);
  if (ret < 0)
    {
      return ret;
    }
  /* Because everything is chunked and aligned to 16-bit boundaries,
   * we know that most the basic node info fits into the sector.  The
   * associated name may not, however.
   */
   next  = nfs_devread32(rm, ndx + ROMFS_FHDR_NEXT);
  *pnext = (save & RFNEXT_OFFSETMASK) | (next & RFNEXT_ALLMODEMASK);
  *pinfo = nfs_devread32(rm, ndx + ROMFS_FHDR_INFO);
  *psize = nfs_devread32(rm, ndx + ROMFS_FHDR_SIZE);
  return OK;
 }
 /****************************************************************************
 * Name: nfs_parsefilename
 *
 * Desciption:
 *   Return the filename from directory entry at this offset
 *
 ****************************************************************************/
 int nfs_parsefilename(struct nfs_mountpt_s *rm, uint32_t offset, char *pname)
 {
  int16_t  ndx;
  uint16_t namelen;
  uint16_t chunklen;
  bool     done;
  /* Loop until the whole name is obtained or until NAME_MAX characters
   * of the name have been parsed.
   */
  offset += ROMFS_FHDR_NAME;
  for (namelen = 0, done = false; namelen < NAME_MAX && !done;)
    {
      /* Read the sector into memory */
      ndx = nfs_devcacheread(rm, offset);
      if (ndx < 0)
        {
          return ndx;
        }
      /* Is the name terminated in this 16-byte block */
      if (rm->rm_buffer[ndx + 15] == '\0')
        {
          /* Yes.. then this chunk is less than 16 */
          chunklen = strlen((char*)&rm->rm_buffer[ndx]);
          done     = true;
        }
      else
        {
          /* No.. then this chunk is 16 bytes in length */
          chunklen = 16;
        }
      /* Check if we would exceed the NAME_MAX */
      if (namelen + chunklen > NAME_MAX)
        {
          chunklen = NAME_MAX - namelen;
          done     = true;
        }
      /* Copy the chunk */
      memcpy(&pname[namelen], &rm->rm_buffer[ndx], chunklen);
      namelen += chunklen;
    }
  /* Terminate the name (NAME_MAX+1 chars total) and return success */
  pname[namelen] = '\0';
  return OK;
 }
 /****************************************************************************
 * Name: nfs_datastart
 *
 * Desciption:
 *   Given the offset to a file header, return the offset to the start of
 *   the file data
 *
 ****************************************************************************/
 int nfs_datastart(struct nfs_mountpt_s *rm, uint32_t offset, uint32_t *start)
 {
  int16_t ndx;
  int     ret;
  /* Traverse hardlinks as necesssary to get to the real file header */
  ret = nfs_followhardlinks(rm, offset, &offset);
  if (ret < 0)
    {
      return ret;
    }
  /* Loop until the header size is obtained. */
  offset += ROMFS_FHDR_NAME;
  for (;;)
    {
      /* Read the sector into memory */
      ndx = nfs_devcacheread(rm, offset);
      if (ndx < 0)
        {
          return ndx;
        }
      /* Get the offset to the next chunk */
      offset += 16;
      if (offset >= rm->rm_volsize)
        {
          return -EIO;
        }
      /* Is the name terminated in this 16-byte block */
      if (rm->rm_buffer[ndx + 15] == '\0')
        {
          /* Yes.. then the data starts at the next chunk */
          *start = offset;
          return OK;
        }
    }
  return -EINVAL; /* Won't get here */
 }
@@ -118,12 +118,15 @@ struct fs_nxffsdir_s
 #endif
 #ifdef CONFIG_NFS
 /* The NFS client file system */
 struct nfsdir_s
 {
  off_t    nd_direoffset;              /* Directory EOF offset */
  uint32_t cookie[2];
-}
+};
 #endif
 #endif /* CONFIG_DISABLE_MOUNTPOINT */
 struct fs_dirent_s