feat(file system): add memory-based romfs

1, this RomFS's codebase is Nuttx romfs, then it is compatible with
   Linux RomFS and you can create such a file system using the tool
   genromfs.
2, there are two major changes against with the original Nuttx romfs:
   1), it is memory-based: all contents of the fs are stored in the
       memory in the very first stage of "mount".
   2), this version of romfs is altered to be compatible with our
       version of VFS to take advantage of vnode cache and path cache.

close: #I3S0CP

fs/romfs/Kconfig

+#
+# For a description of the syntax of this configuration file,
+# see the file kconfig-language.txt in the NuttX tools repository.
+#
+
+config FS_ROMFS
+	bool "ROMFS file system"
+	default n
+	depends on !DISABLE_MOUNTPOINT
+	select FS_READABLE
+	---help---
+		Enable ROMFS filesystem support
+
+if FS_ROMFS
+endif

fs/romfs/Make.defs

+############################################################################
+# fs/romfs/Make.defs
+#
+#   Copyright (C) 2008, 2011, 2013 Gregory Nutt. All rights reserved.
+#   Author: Gregory Nutt <gnutt@nuttx.org>
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# 1. Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in
+#    the documentation and/or other materials provided with the
+#    distribution.
+# 3. Neither the name Nuttx nor the names of its contributors may be
+#    used to endorse or promote products derived from this software
+#    without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+# OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+#
+############################################################################
+
+ifeq ($(CONFIG_FS_ROMFS),y)
+# Files required for ROMFS file system support
+
+ASRCS +=
+CSRCS += fs_romfs.c fs_romfsutil.c
+
+# Include ROMFS build support
+
+DEPPATH += --dep-path romfs
+VPATH += :romfs
+
+endif

fs/romfs/fs_romfs.h

+/****************************************************************************
+ * fs/romfs/fs_romfs.h
+ *
+ *   Copyright (C) 2008-2009, 2011 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <gnutt@nuttx.org>
+ *
+ * References: Linux/Documentation/filesystems/romfs.txt
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ * 3. Neither the name NuttX nor the names of its contributors may be
+ *    used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ ****************************************************************************/
+
+#ifndef __FS_ROMFS_FS_ROMFS_H
+#define __FS_ROMFS_FS_ROMFS_H
+
+/****************************************************************************
+ * Included Files
+ ****************************************************************************/
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#include <fs/dirent_fs.h>
+
+#include "disk.h"
+
+/****************************************************************************
+ * Pre-processor Definitions
+ ****************************************************************************/
+
+/* Volume header (multi-byte values are big-endian) */
+#define ROMFS_MAGIC         0x7275
+
+#define ROMFS_VHDR_ROM1FS   0  /*  0-7:  "-rom1fs-" */
+#define ROMFS_VHDR_SIZE     8  /*  8-11: Number of accessible bytes in this fs. */
+#define ROMFS_VHDR_CHKSUM  12  /* 12-15: Checksum of the first 512 bytes. */
+#define ROMFS_VHDR_VOLNAME 16  /* 16-..: Zero terminated volume name, padded to
+                                *        16 byte boundary. */
+
+#define ROMFS_VHDR_MAGIC   "-rom1fs-"
+
+/* File header offset (multi-byte values are big-endian) */
+
+#define ROMFS_FHDR_NEXT     0  /*  0-3:  Offset of the next file header
+                                *        (zero if no more files) */
+#define ROMFS_FHDR_INFO     4  /*  4-7:  Info for directories/hard links/
+                                *        devices */
+#define ROMFS_FHDR_SIZE     8  /*  8-11: Size of this file in bytes */
+#define ROMFS_FHDR_CHKSUM  12  /* 12-15: Checksum covering the meta data,
+                                *        including the file name, and
+                                *        padding. */
+#define ROMFS_FHDR_NAME    16  /* 16-..: Zero terminated volume name, padded
+                                *        to 16 byte boundary. */
+
+/* Bits 0-3 of the rf_next offset provide mode information.  These are the
+ * values specified in  */
+
+#define RFNEXT_MODEMASK    7    /* Bits 0-2: Mode; bit 3: Executable */
+#define RFNEXT_ALLMODEMASK 15   /* Bits 0-3: All mode bits */
+#define RFNEXT_OFFSETMASK (~15) /* Bits n-3: Offset to next entry */
+
+#define RFNEXT_HARDLINK    0    /* rf_info = Link destination file header */
+#define RFNEXT_DIRECTORY   1    /* rf_info = First file's header */
+#define RFNEXT_FILE        2    /* rf_info = Unused, must be zero */
+#define RFNEXT_SOFTLINK    3    /* rf_info = Unused, must be zero */
+#define RFNEXT_BLOCKDEV    4    /* rf_info = 16/16 bits major/minor number */
+#define RFNEXT_CHARDEV     5    /* rf_info = 16/16 bits major/minor number */
+#define RFNEXT_SOCKET      6    /* rf_info = Unused, must be zero */
+#define RFNEXT_FIFO        7    /* rf_info = Unused, must be zero */
+#define RFNEXT_EXEC        8    /* Modifier of RFNEXT_DIRECTORY and RFNEXT_FILE */
+
+#define IS_MODE(rfn,mode)  ((((uint32_t)(rfn))&RFNEXT_MODEMASK)==(mode))
+#define IS_HARDLINK(rfn)   IS_MODE(rfn,RFNEXT_HARDLINK)
+#define IS_DIRECTORY(rfn)  IS_MODE(rfn,RFNEXT_DIRECTORY)
+#define IS_FILE(rfn)       IS_MODE(rfn,RFNEXT_FILE)
+#define IS_EXECUTABLE(rfn) (((rfn) & RFNEXT_EXEC) != 0)
+
+/* RFNEXT_SOFTLINK, RFNEXT_BLOCKDEV, RFNEXT_CHARDEV, RFNEXT_SOCKET, and
+ * RFNEXT_FIFO are not presently supported.
+ */
+
+/* Alignment macros */
+
+#define ROMFS_ALIGNMENT       16
+#define ROMFS_MAXPADDING      (ROMFS_ALIGNMENT-1)
+#define ROMFS_ALIGNMASK       (~ROMFS_MAXPADDING)
+#define ROMFS_ALIGNUP(addr)   ((((uint32_t)(addr))+ROMFS_MAXPADDING)&ROMFS_ALIGNMASK)
+#define ROMFS_ALIGNDOWN(addr) (((uint32_t)(addr))&ROMFS_ALIGNMASK)
+
+/* Offset and sector conversions */
+
+#define SEC_NDXMASK(r)       ((r)->rm_hwsectorsize - 1)
+#define SEC_NSECTORS(r,o)    ((o) / (r)->rm_hwsectorsize)
+#define SEC_ALIGN(r,o)       ((o) & ~SEC_NDXMASK(r))
+
+/* Maximum numbr of links that will be followed before we decide that there
+ * is a problem.
+ */
+
+#define ROMF_MAX_LINKS 64
+
+/****************************************************************************
+ * Public Types
+ ****************************************************************************/
+
+/* This structure represents the overall mountpoint state.  An instance of this
+ * structure is retained as inode private data on each mountpoint that is
+ * mounted with a fat32 filesystem.
+ */
+
+struct romfs_file_s;
+struct romfs_mountpt_s
+{
+  struct inode        *rm_blkdriver; /* The block driver inode that hosts the FAT32 fs */
+  struct romfs_file_s *rm_head;      /* A list to all files opened on this mountpoint */
+
+  bool     rm_mounted;              /* true: The file system is ready */
+  uint16_t rm_hwsectorsize;         /* HW: Sector size reported by block driver*/
+  sem_t    rm_sem;                  /* Used to assume thread-safe access */
+  uint32_t rm_rootoffset;           /* Saved offset to the first root directory entry */
+  uint32_t rm_hwnsectors;           /* HW: The number of sectors reported by the hardware */
+  uint32_t rm_volsize;              /* Size of the ROMFS volume */
+  uint32_t rm_cachesector;          /* Current sector in the rm_buffer */
+  uint8_t *rm_xipbase;              /* Base address of directly accessible media */
+  uint8_t *rm_buffer;               /* Device sector buffer, allocated if rm_xipbase==0 */
+};
+
+/* This structure represents on open file under the mountpoint.  An instance
+ * of this structure is retained as struct file specific information on each
+ * opened file.
+ */
+
+struct romfs_file_s
+{
+  FAR struct romfs_file_s *rf_next; /* Retained in a singly linked list */
+  uint32_t rf_startoffset;          /* Offset to the start of the file data */
+  uint32_t rf_size;                 /* Size of the file in bytes */
+  uint32_t rf_cachesector;          /* Current sector in the rf_buffer */
+  uint8_t *rf_buffer;               /* File sector buffer, allocated if rm_xipbase==0 */
+  uint8_t rf_type;                  /* File type (for fstat()) */
+};
+
+/* This structure is used internally for describing the result of
+ * walking a path
+ */
+
+struct fs_romfsdir_s
+{
+  off_t fr_firstoffset;
+  off_t fr_curroffset;
+};
+struct romfs_dirinfo_s
+{
+  /* These values describe the directory containing the terminal
+   * path component (of the terminal component itself if it is
+   * a directory.
+   */
+
+  struct fs_romfsdir_s rd_dir;    /* Describes directory. */
+
+  /* Values from the ROMFS file entry */
+
+  uint32_t rd_next;               /* Offset of the next file header+flags */
+  uint32_t rd_size;               /* Size (if file) */
+};
+
+/****************************************************************************
+ * Public Data
+ ****************************************************************************/
+
+#undef EXTERN
+#if defined(__cplusplus)
+#define EXTERN extern "C"
+extern "C"
+{
+#else
+#define EXTERN extern
+#endif
+
+/****************************************************************************
+ * Public Function Prototypes
+ ****************************************************************************/
+
+void romfs_semtake(FAR struct romfs_mountpt_s *rm);
+void romfs_semgive(FAR struct romfs_mountpt_s *rm);
+int  romfs_hwread(FAR struct romfs_mountpt_s *rm, FAR uint8_t *buffer,
+       uint32_t sector, unsigned int nsectors);
+int  romfs_filecacheread(FAR struct romfs_mountpt_s *rm,
+       FAR struct romfs_file_s *rf, uint32_t sector);
+int  romfs_hwconfigure(FAR struct romfs_mountpt_s *rm);
+int  romfs_fsconfigure(FAR struct romfs_mountpt_s *rm);
+int  romfs_checkmount(FAR struct romfs_mountpt_s *rm);
+int  romfs_finddirentry(FAR struct romfs_mountpt_s *rm,
+       FAR struct romfs_dirinfo_s *dirinfo,
+       FAR const char *path);
+int  romfs_parsedirentry(FAR struct romfs_mountpt_s *rm,
+       uint32_t offset, FAR uint32_t *poffset, FAR uint32_t *pnext,
+       FAR uint32_t *pinfo, FAR uint32_t *psize);
+int  romfs_parsefilename(FAR struct romfs_mountpt_s *rm, uint32_t offset,
+       FAR char *pname);
+int  romfs_datastart(FAR struct romfs_mountpt_s *rm, uint32_t offset,
+       FAR uint32_t *start);
+int romfs_searchdir(struct romfs_mountpt_s *rm,
+       const char *entryname, int entrylen, uint32_t firstoffset,
+       struct romfs_dirinfo_s *dirinfo);
+
+#undef EXTERN
+#if defined(__cplusplus)
+}
+#endif
+
+#endif /* __FS_ROMFS_FS_ROMFS_H */

fs/romfs/fs_romfsutil.c

+/****************************************************************************
+ * rm/romfs/fs_romfsutil.c
+ *
+ *   Copyright (C) 2008-2009, 2013, 2017 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <gnutt@nuttx.org>
+ *
+ * References: Linux/Documentation/filesystems/romfs.txt
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ * 3. Neither the name NuttX nor the names of its contributors may be
+ *    used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ ****************************************************************************/
+
+/****************************************************************************
+ * Included Files
+ ****************************************************************************/
+
+#include <sys/types.h>
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <errno.h>
+#include <assert.h>
+#include <debug.h>
+
+#ifdef LOSCFG_FS_ROMFS
+#include "fs_romfs.h"
+
+/****************************************************************************
+ * Private Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: romfs_swap32
+ *
+ * Description:
+ *   Convert the 32-bit big-endian value to little endian
+ *
+ ****************************************************************************/
+
+inline uint32_t romfs_swap32(uint32_t value)
+{
+  return ((((value) & 0x000000ff) << 24) | (((value) & 0x0000ff00) << 8) |
+          (((value) & 0x00ff0000) >>  8) | (((value) & 0xff000000) >> 24));
+}
+
+/****************************************************************************
+ * Name: romfs_devread32
+ *
+ * Description:
+ *   Read the big-endian 32-bit value from the mount device buffer
+ *
+ * Assumption:
+ *   All values are aligned to 32-bit boundaries
+ *
+ ****************************************************************************/
+
+static uint32_t romfs_devread32(struct romfs_mountpt_s *rm, int ndx)
+{
+  /* Extract the value */
+
+  uint32_t value = *(uint32_t *)&rm->rm_buffer[ndx];
+
+  /* Convert the big-endian value to native host endianness. */
+
+  return romfs_swap32(value);
+}
+
+/****************************************************************************
+ * Name: romfs_checkentry
+ *
+ * Description:
+ *   Check if the entry at offset is a directory or file path segment
+ *
+ ****************************************************************************/
+
+static inline int romfs_checkentry(struct romfs_mountpt_s *rm,
+                                   uint32_t offset, const char *entryname,
+                                   int entrylen,
+                                   struct romfs_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 = romfs_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 = romfs_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: romfs_devcacheread
+ *
+ * Description:
+ *   Read the specified sector for specified offset into the sector cache.
+ *   Return the index into the sector corresponding to the offset
+ *
+ ****************************************************************************/
+
+uint32_t romfs_devcacheread(struct romfs_mountpt_s *rm, uint32_t offset)
+{
+  return offset;
+}
+
+/****************************************************************************
+ * Name: romfs_followhardlinks
+ *
+ * Description:
+ *   Given the offset to a file header, check if the file is a hardlink.
+ *   If so, traverse the hard links until the terminal, non-linked header
+ *   so found and return that offset.
+ *
+ ****************************************************************************/
+
+static int romfs_followhardlinks(struct romfs_mountpt_s *rm, uint32_t offset,
+                                 uint32_t *poffset)
+{
+  uint32_t next;
+  uint32_t ndx;
+  int      i;
+
+  /* Loop while we are redirected by hardlinks */
+
+  for (i = 0; i < ROMF_MAX_LINKS; i++)
+    {
+      /* Read the sector containing the offset into memory */
+
+      ndx = romfs_devcacheread(rm, offset);
+      if (ndx < 0)
+        {
+          return ndx;
+        }
+
+      /* Check if this is a hard link */
+
+      next = romfs_devread32(rm, ndx + ROMFS_FHDR_NEXT);
+      if (!IS_HARDLINK(next))
+        {
+          *poffset = offset;
+          return OK;
+        }
+
+      /* Follow the hard-link */
+
+      offset = romfs_devread32(rm, ndx + ROMFS_FHDR_INFO);
+    }
+
+  return -ELOOP;
+}
+
+/****************************************************************************
+ * Name: romfs_searchdir
+ *
+ * Description:
+ *   This is part of the romfs_finddirentry log.  Search the directory
+ *   beginning at dirinfo->fr_firstoffset for entryname.
+ *
+ ****************************************************************************/
+
+int romfs_searchdir(struct romfs_mountpt_s *rm,
+                                  const char *entryname, int entrylen, uint32_t firstoffset,
+                                  struct romfs_dirinfo_s *dirinfo)
+{
+  uint32_t offset;
+  uint32_t next;
+  uint32_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 = firstoffset;
+  do
+    {
+      /* Read the sector into memory (do this before calling
+       * romfs_checkentry() so we won't have to read the sector
+       * twice in the event that the offset refers to a hardlink).
+       */
+
+      ndx = romfs_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 = romfs_devread32(rm, ndx + ROMFS_FHDR_NEXT) & RFNEXT_OFFSETMASK;
+
+      /* Check if the name this entry is a directory with the matching
+       * name
+       */
+
+      ret = romfs_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 directory with that name */
+
+  return -ENOENT;
+}
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: romfs_semtake
+ ****************************************************************************/
+
+void romfs_semtake(struct romfs_mountpt_s *rm)
+{
+  int ret;
+
+  do
+    {
+      /* Take the semaphore (perhaps waiting) */
+
+      ret = sem_wait(&rm->rm_sem);
+
+      /* The only case that an error should occur here is if the wait was
+       * awakened by a signal.
+       */
+
+      DEBUGASSERT(ret == OK || ret == -EINTR);
+    }
+  while (ret == -EINTR);
+}
+
+/****************************************************************************
+ * Name: romfs_semgive
+ ****************************************************************************/
+
+void romfs_semgive(struct romfs_mountpt_s *rm)
+{
+  (void)sem_post(&rm->rm_sem);
+}
+
+/****************************************************************************
+ * Name: romfs_hwconfigure
+ *
+ * Description:
+ *   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 romfs_hwconfigure(struct romfs_mountpt_s *rm)
+{
+  uint32_t total_size;
+
+  rm->rm_buffer = (uint8_t *)DMA_TO_VMM_ADDR(RAMDISK_ADDR);
+  total_size = romfs_devread32(rm, ROMFS_VHDR_SIZE);
+
+  rm->rm_hwnsectors = total_size;
+  rm->rm_hwsectorsize = 1;
+  rm->rm_cachesector = (uint32_t)-1;
+  rm->rm_volsize = total_size;
+
+  rm->rm_buffer = (uint8_t *)malloc(total_size);
+  if (!rm->rm_buffer)
+    {
+      return -ENOMEM;
+    }
+
+  memcpy(rm->rm_buffer, (void *)DMA_TO_VMM_ADDR(RAMDISK_ADDR), total_size);
+
+  return OK;
+}
+
+/****************************************************************************
+ * Name: romfs_fsconfigure
+ *
+ * Description:
+ *   This function is called as part of the ROMFS mount operation   It
+ *   sets up the mount structure to include configuration information contained
+ *   in the ROMFS header.  This is the place where we actually determine if
+ *   the media contains a ROMFS filesystem.
+ *
+ ****************************************************************************/
+
+int romfs_fsconfigure(struct romfs_mountpt_s *rm)
+{
+  const char *name;
+  uint32_t    ndx;
+
+  /* Then get information about the ROMFS filesystem on the devices managed
+   * by this block driver.  Read sector zero which contains the volume header.
+   */
+
+  ndx = romfs_devcacheread(rm, 0);
+  if (ndx < 0)
+    {
+      return ndx;
+    }
+
+  /* Verify the magic number at that identifies this as a ROMFS filesystem */
+
+  if (memcmp(rm->rm_buffer, ROMFS_VHDR_MAGIC, 8) != 0)
+    {
+      return -EINVAL;
+    }
+
+  /* The root directory entry begins right after the header */
+
+  name              = (FAR const char *)&rm->rm_buffer[ROMFS_VHDR_VOLNAME];
+  rm->rm_rootoffset = ROMFS_ALIGNUP(ROMFS_VHDR_VOLNAME + strlen(name) + 1);
+
+  /* and return success */
+
+  rm->rm_mounted    = true;
+  return OK;
+}
+
+/****************************************************************************
+ * Name: romfs_checkmount
+ *
+ * Description: Check if the mountpoint is still valid.
+ *
+ *   The caller should hold the mountpoint semaphore
+ *
+ ****************************************************************************/
+
+int romfs_checkmount(struct romfs_mountpt_s *rm)
+{
+  return OK;
+}
+
+/****************************************************************************
+ * Name: romfs_parsedirentry
+ *
+ * Description:
+ *   Return the directory entry at this offset.  If rf is NULL, then the
+ *   mount device resources are used.  Otherwise, file resources are used.
+ *
+ ****************************************************************************/
+
+int romfs_parsedirentry(struct romfs_mountpt_s *rm, uint32_t offset,
+                        uint32_t *poffset, uint32_t *pnext, uint32_t *pinfo,
+                        uint32_t *psize)
+{
+  uint32_t save;
+  uint32_t next;
+  uint32_t ndx;
+  int      ret;
+
+  /* Read the sector into memory */
+
+  ndx = romfs_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 = romfs_devread32(rm, ndx + ROMFS_FHDR_NEXT);
+
+  /* Traverse hardlinks as necessary to get to the real file header */
+
+  ret = romfs_followhardlinks(rm, offset, poffset);
+  if (ret < 0)
+    {
+      return ret;
+    }
+
+  if (*poffset != offset)
+    {
+      ndx = romfs_devcacheread(rm, *poffset);
+      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.  The
+   * associated name may not, however.
+   */
+
+  next   = romfs_devread32(rm, ndx + ROMFS_FHDR_NEXT);
+  *pnext = (save & RFNEXT_OFFSETMASK) | (next & RFNEXT_ALLMODEMASK);
+  *pinfo = romfs_devread32(rm, ndx + ROMFS_FHDR_INFO);
+  *psize = romfs_devread32(rm, ndx + ROMFS_FHDR_SIZE);
+
+  return OK;
+}
+
+/****************************************************************************
+ * Name: romfs_parsefilename
+ *
+ * Description:
+ *   Return the filename from directory entry at this offset
+ *
+ ****************************************************************************/
+
+int romfs_parsefilename(struct romfs_mountpt_s *rm, uint32_t offset,
+                        char *pname)
+{
+  uint32_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 = romfs_devcacheread(rm, offset + namelen);
+      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((FAR 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: romfs_datastart
+ *
+ * Description:
+ *   Given the offset to a file header, return the offset to the start of
+ *   the file data
+ *
+ ****************************************************************************/
+
+int romfs_datastart(struct romfs_mountpt_s *rm, uint32_t offset,
+                    uint32_t *start)
+{
+  uint32_t ndx;
+  int      ret;
+
+  /* Traverse hardlinks as necessary to get to the real file header */
+
+  ret = romfs_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 = romfs_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 */
+}
+
+#endif
\ No newline at end of file