!41 memory-based romfs

Merge pull request !41 from LeonChan/lc-master

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