fs/mnemofs: Add mnemofs version 1 support.

Split mnemofs into allocation, directory, file, CTZ, and read/write modules, and update direntry traversal and file handling. Add superblock format version 1 support, reject newer on-flash versions, and preserve the mounted version when rewriting metadata. Update the NAND simulator drivers for the new mnemofs behavior by fixing spare writes, exposing the erase state, allowing raw reads, and documenting the background-task startup flow. Signed-off-by: Saurav Pal <resyfer.dev@gmail.com>
2026-05-23 14:58:13 +08:00 · 2026-05-15 23:14:23 +05:30
parent 319ca656b8
commit 4f6e695f7c
19 changed files with 9246 additions and 9597 deletions
@@ -152,15 +152,18 @@ is still the wrapper, not the actual upper half, as the upper half methods
 may call the other methods as well internally and we might want to log
 them as well*.

-Registering Device & Daemon
-===========================
+Registering Device & Background Task
+====================================

 This wrapper is then registered using ``register_mtddriver``, and this
-whole thing is converted to be a daemon, so that the device can keep running
-in the background.
+whole thing is launched as a background task, so that the device can keep
+running after the ``nand`` command returns to the shell.

-Making it a daemon is achieved by using ``fork()``, killing the parent, and
-using ``daemon()`` in child.
+The ``nand`` command starts a dedicated NuttX task with ``task_create()``,
+waits until the device registration finishes, and then returns control to
+the shell. This keeps the simulator alive in the background without relying
+on ``fork()``, whose post-fork execution model is not appropriate for this
+kind of long-running initialization in the flat build used by the simulator.

 Known Issues
 ============
@@ -168,4 +171,4 @@ Known Issues
 * ECC is not implemented yet.
 * MLC NAND Flash is not implemented yet.
 * Due to the fixed name of the device, there can't be more than one instance
-  of this virtual device.
+  of this virtual device.
@@ -332,12 +332,10 @@ int nand_ram_eraseblock(FAR struct nand_raw_s *raw, off_t block)
 int nand_ram_rawread(FAR struct nand_raw_s *raw, off_t block,
                      unsigned int page, FAR void *data, FAR void *spare)
 {
-  int                     ret;
  uint32_t                read_page;
  struct nand_ram_data_s  *read_page_data;
  struct nand_ram_spare_s *read_page_spare;

-  ret             = OK;
  read_page       = (block << NAND_RAM_LOG_PAGES_PER_BLOCK) + page;
  read_page_data  = nand_ram_flash_data + read_page;
  read_page_spare = nand_ram_flash_spare + read_page;
@@ -349,14 +347,6 @@ int nand_ram_rawread(FAR struct nand_raw_s *raw, off_t block,
              nand_ram_ins_i, "rawread", read_page);
  nand_ram_status();

-  if (nand_ram_flash_spare[read_page].bad != NAND_RAM_BLOCK_GOOD)
-    {
-      ret = -EFAULT;
-      NAND_RAM_LOG("[LOWER %" PRIu64 " | %s] Failed: %s\n",
-                    nand_ram_ins_i, "rawread", EFAULT_STR);
-      goto errout;
-    }
-
  nand_ram_flash_spare[read_page].n_read++;

  if (data != NULL)
@@ -378,11 +368,9 @@ int nand_ram_rawread(FAR struct nand_raw_s *raw, off_t block,
    }

  NAND_RAM_LOG("[LOWER %" PRIu64 " | %s] Done\n", nand_ram_ins_i, "rawread");
-
-errout:
  nxmutex_unlock(&nand_ram_dev_mut);

-  return ret;
+  return OK;
 }

 /****************************************************************************
@@ -444,7 +432,7 @@ int nand_ram_rawwrite(FAR struct nand_raw_s *raw, off_t block,

  if (spare != NULL)
    {
-      memcpy((FAR void *)write_page_spare, data, NAND_RAM_SPARE_SIZE);
+      memcpy((FAR void *)write_page_spare, spare, NAND_RAM_SPARE_SIZE);
    }

  NAND_RAM_LOG("[LOWER %" PRIu64 " | %s] Done\n", nand_ram_ins_i,
@@ -272,6 +272,7 @@ int nand_wrapper_ioctl(FAR struct mtd_dev_s *dev, int cmd,
                       unsigned long arg)
 {
  int ret;
+  FAR uint8_t *erasestate;
  FAR struct nand_wrapper_dev_s *nand_dev;

  nand_dev = (struct nand_wrapper_dev_s *)dev;
@@ -282,7 +283,28 @@ int nand_wrapper_ioctl(FAR struct mtd_dev_s *dev, int cmd,
                   ", Arg : %zu\n", nand_wrapper_ins_i, "ioctl", cmd, arg);
  DEBUGASSERT(nand_dev && nand_dev->under.mtd.ioctl);

-  ret = nand_dev->under.mtd.ioctl(dev, cmd, arg);
+  if (cmd == MTDIOC_ERASESTATE)
+    {
+      erasestate = (FAR uint8_t *)arg;
+      if (erasestate == NULL)
+        {
+          ret = -EINVAL;
+        }
+      else
+        {
+          /* The wrapped bread path exposes blank NAND pages as zero-filled
+           * buffers after ECC handling, so report the same visible erase
+           * state to higher layers.
+           */
+
+          *erasestate = 0x00;
+          ret = OK;
+        }
+    }
+  else
+    {
+      ret = nand_dev->under.mtd.ioctl(dev, cmd, arg);
+    }

  if (ret >= 0)
    {
@@ -49,15 +49,6 @@
 # ##############################################################################

 if(CONFIG_FS_MNEMOFS)
-  target_sources(
-    fs
-    PRIVATE mnemofs_blkalloc.c
-            mnemofs_ctz.c
-            mnemofs_fsobj.c
-            mnemofs_journal.c
-            mnemofs_lru.c
-            mnemofs_master.c
-            mnemofs_rw.c
-            mnemofs_util.c
-            mnemofs.c)
+  target_sources(fs PRIVATE mnemofs.c mnemofs_alloc.c mnemofs_ctz.c
+                            mnemofs_dirent.c mnemofs_file.c mnemofs_rw.c)
 endif()
@@ -9,44 +9,3 @@ config FS_MNEMOFS
 	depends on !DISABLE_MOUNTPOINT && MTD_NAND
 	---help---
 		Build the mnemofs NAND flash file system.
-
-if FS_MNEMOFS
-config MNEMOFS_EXTRA_DEBUG
-	bool "MNEMOFS Extra Debug Logs"
-	default n
-	depends on FS_MNEMOFS
-	---help---
-		Prints extra log information related to mnemofs.
-
-config MNEMOFS_JOURNAL_NBLKS
-	int "MNEMOFS Journal Block Count"
-	default 20
-	range 4 65536
-	depends on FS_MNEMOFS
-	---help---
-		Number of blocks that mnemofs will use for the journal. Specifying
-		this will only work on formatting a NAND flash using mnemofs. If the
-		device is already formatted, the on-flash journal block count will
-		be considered instead. Two additional blocks will be allocated for
-		the master blocks.
-
-config MNEMOFS_NLRU
-	int "MNEMOFS LRU Node Count"
-	default 20
-	range 1 255
-	depends on FS_MNEMOFS
-	---help---
-		Number of nodes used by mnemofs for LRU. The higher the value is,
-		the lesser would be the wear on device with higher RAM
-		consumption.
-
-config MNEMOFS_NLRUDELTA
-	int "MNEMOFS LRU Delta Count"
-	default 20
-	range 1 255
-	depends on FS_MNEMOFS
-	---help---
-		Number of deltas used by mnemofs for LRU for every node. The higher
-		the value is, the lesser would be the wear on device with higher RAM
-		consumption.
-endif # FS_MNEMOFS
@@ -54,15 +54,12 @@ ifeq ($(CONFIG_FS_MNEMOFS),y)

 # Add the mnemofs C files to the build

-CSRCS += mnemofs_blkalloc.c
-CSRCS += mnemofs_ctz.c
-CSRCS += mnemofs_fsobj.c
-CSRCS += mnemofs_journal.c
-CSRCS += mnemofs_lru.c
-CSRCS += mnemofs_master.c
-CSRCS += mnemofs_rw.c
-CSRCS += mnemofs_util.c
 CSRCS += mnemofs.c
+CSRCS += mnemofs_alloc.c
+CSRCS += mnemofs_ctz.c
+CSRCS += mnemofs_dirent.c
+CSRCS += mnemofs_file.c
+CSRCS += mnemofs_rw.c

 # Add the mnemofs directory to the build

@@ -1,453 +0,0 @@
-/****************************************************************************
- * fs/mnemofs/mnemofs_master.c
- *
- * SPDX-License-Identifier: Apache-2.0 or BSD-3-Clause
- *
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.  The
- * ASF licenses this file to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the
- * License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- * Alternatively, the contents of this file may be used under the terms of
- * the BSD-3-Clause license:
- *
- * SPDX-License-Identifier: BSD-3-Clause
- *
- * Copyright (c) 2024 Saurav Pal
- *
- * 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 of the author nor the names of its contributors may
- *    be used to endorse or promote products derived from this software
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- *
- ****************************************************************************/
-
-/****************************************************************************
- * In mnemofs, the master node points to the root of the file system. It
- * contains the information about the root, and when the root is updated,
- * the master node needs to point to the updated location, and thus, needs to
- * update the master node.
- *
- * Master nodes sit at the very end of the journal. The last two blocks of
- * the journal are called master blocks, and they are filled with a new
- * entry for a master node every time it is updated. They are filled in a
- * sequential manner, and thus, the latest master node can be found easily.
- * The two master blocks contain identical information, and exist to be as a
- * backup.
- *
- * The stored master nodes are basically `struct mfs_mn_s` without the
- * redundant `pg` member.
- *
- * The master node also points to the start of the journal, and thus, when
- * the journal moves, a new master node entry is added.
- *
- * A master node update, when written to the file system, marks the end of
- * an update of the file system tree. Thus, at this point, any obsolete data
- * that can be erased, will be erased by the block allocator. Only after
- * writing the master block is the file system tree updated. Before this,
- * the old file system tree is accessible through the older master node, and
- * can be accessed again during power loss.
- ****************************************************************************/
-
-/****************************************************************************
- * Included Files
- ****************************************************************************/
-
-#include <nuttx/kmalloc.h>
-#include <sys/stat.h>
-
-#include "mnemofs.h"
-
-/****************************************************************************
- * Pre-processor Definitions
- ****************************************************************************/
-
-/****************************************************************************
- * Private Types
- ****************************************************************************/
-
-/****************************************************************************
- * Private Function Prototypes
- ****************************************************************************/
-
-static FAR char       *ser_mn(const struct mfs_mn_s mn,
-                              FAR char * const out);
-static FAR const char *deser_mn(FAR const char * const in,
-                                FAR struct mfs_mn_s *mn, FAR uint16_t *hash);
-
-/****************************************************************************
- * Private Data
- ****************************************************************************/
-
-/****************************************************************************
- * Public Data
- ****************************************************************************/
-
-/****************************************************************************
- * Private Functions
- ****************************************************************************/
-
-/****************************************************************************
- * Name: ser_mn
- *
- * Description:
- *   Serialize master node.
- *
- * Input Parameters:
- *   mn  - Master node.
- *   out - Out buffer.
- *
- * Returned Value:
- *   Pointer to the end of the serialized data in `out`.
- *
- * Assumptions/Limitations:
- *   Out should contain enough space for `mn` and 1 byte extra for the hash.
- *
- ****************************************************************************/
-
-static FAR char *ser_mn(const struct mfs_mn_s mn, FAR char * const out)
-{
-  FAR char *tmp = out;
-
-  tmp = mfs_ser_mfs(mn.jrnl_blk, tmp);
-  tmp = mfs_ser_mfs(mn.mblk_idx, tmp);
-  tmp = mfs_ser_ctz(&mn.root_ctz, tmp);
-  tmp = mfs_ser_mfs(mn.root_sz, tmp);
-  tmp = mfs_ser_timespec(&mn.ts, tmp);
-  tmp = mfs_ser_16(mfs_hash(out, tmp - out), tmp);
-
-  /* TODO: Update this, and the make a macro for size of MN. */
-
-  return tmp;
-}
-
-/****************************************************************************
- * Name: ser_mn
- *
- * Description:
- *   Deserialize master node.
- *
- * Input Parameters:
- *   in   - In buffer.
- *   mn   - Master node to populate.
- *   hash - Stored hash (of serialized data) to populate.
- *
- * Returned Value:
- *   Pointer to the end of the serialized data in `in`.
- *
- * Assumptions/Limitations:
- *   In should contain enough space for `mn` and 1 byte extra for the hash.
- *
- ****************************************************************************/
-
-static FAR const char *deser_mn(FAR const char * const in,
-                                FAR struct mfs_mn_s *mn, FAR uint16_t *hash)
-{
-  FAR const char *tmp = in;
-
-  tmp = mfs_deser_mfs(tmp, &mn->jrnl_blk);
-  tmp = mfs_deser_mfs(tmp, &mn->mblk_idx);
-  tmp = mfs_deser_ctz(tmp, &mn->root_ctz);
-  tmp = mfs_deser_mfs(tmp, &mn->root_sz);
-  tmp = mfs_deser_timespec(tmp, &mn->ts);
-  tmp = mfs_deser_16(tmp, hash);
-
-  /* TODO: Update this, and the make a macro for size of MN. */
-
-  return tmp;
-}
-
-/****************************************************************************
- * Public Functions
- ****************************************************************************/
-
-int mfs_mn_init(FAR struct mfs_sb_s * const sb, const mfs_t jrnl_blk)
-{
-  int             ret          = OK;
-  bool            found        = false;
-  mfs_t           i            = 0;
-  mfs_t           mblk1;
-  mfs_t           blkidx;
-  mfs_t           pg_in_blk;
-  mfs_t           jrnl_blk_tmp;
-  uint16_t        hash;
-  struct mfs_mn_s mn;
-  const mfs_t     sz           = sizeof(struct mfs_mn_s) - sizeof(mn.pg);
-  char            buftmp[4];
-  char            buf[sz + 1];
-  struct mfs_jrnl_log_s log;
-
-  mblk1       = mfs_jrnl_blkidx2blk(sb, MFS_JRNL(sb).n_blks);
-
-  mn.jrnl_blk = jrnl_blk;
-  mn.mblk_idx = 0;
-  mn.pg       = MFS_BLK2PG(sb, mblk1);
-
-  for (i = 0; i < MFS_PGINBLK(sb); i++)
-    {
-      mfs_read_page(sb, buftmp, 4, mn.pg, 0);
-      mfs_deser_mfs(buftmp, &jrnl_blk_tmp);
-
-      if (jrnl_blk_tmp == 0)
-        {
-          break;
-        }
-
-      found = true;
-      mn.mblk_idx++;
-      mn.pg++;
-    }
-
-  if (found == false)
-    {
-      ret = -EINVAL;
-      goto errout;
-    }
-
-  if (i == MFS_PGINBLK(sb))
-    {
-      ret = -ENOSPC;
-      goto errout;
-    }
-  else
-    {
-      mn.pg--;
-    }
-
-  mfs_read_page(sb, buf, sz + 1, mn.pg, 0);
-  deser_mn(buf, &mn, &hash);
-  if (hash != mfs_hash(buf, sz))
-    {
-      ret = -EINVAL;
-      goto errout;
-    }
-
-  blkidx              = MFS_JRNL(sb).log_sblkidx;
-  pg_in_blk           = MFS_JRNL(sb).log_spg % MFS_PGINBLK(sb);
-
-  while (true)
-    {
-      ret = mfs_jrnl_rdlog(sb, &blkidx, &pg_in_blk, &log);
-      if (predict_false(ret < 0 && ret != -ENOSPC))
-        {
-          goto errout;
-        }
-      else if (ret == -ENOSPC)
-        {
-          ret = OK;
-          break;
-        }
-
-      /* Assumes checking the depth is enough to check if it's empty, as
-       * theoretically there are no blocks with depth 0, as root has a
-       * depth of 1.
-       */
-
-      if (log.depth == 0)
-        {
-          DEBUGASSERT(log.path == NULL);
-          break;
-        }
-
-      if (log.depth == 1)
-        {
-          mn.root_ctz = log.loc_new;
-          mn.root_sz  = log.sz_new;
-        }
-
-      mfs_jrnl_log_free(&log);
-    }
-
-  /* FUTURE TODO: Recovery in case of hash not matching, or page not
-   * readable.
-   */
-
-  mn.root_mode = 0777 | S_IFDIR;
-
-  MFS_MN(sb) = mn;
-errout:
-  return ret;
-}
-
-int mfs_mn_fmt(FAR struct mfs_sb_s * const sb, const mfs_t mblk1,
-               const mfs_t mblk2, const mfs_t jrnl_blk)
-{
-  int              ret         = OK;
-  mfs_t            pg;
-  struct mfs_mn_s  mn;
-  struct timespec  ts;
-  const mfs_t      sz          = sizeof(struct mfs_mn_s) - sizeof(mn.pg);
-  char             buf[sz + 1];
-
-  clock_gettime(CLOCK_REALTIME, &ts);
-
-  memset(buf, 0, sz + 1);
-
-  pg = mfs_ba_getpg(sb);
-  if (predict_false(pg == 0))
-    {
-      ret = -ENOSPC;
-      goto errout;
-    }
-
-  finfo("Root formatted to be at Page %u", pg);
-
-  mn.root_ctz.idx_e = 0;
-  mn.root_ctz.pg_e  = pg;
-  mn.jrnl_blk       = jrnl_blk;
-  mn.mblk_idx       = 0;
-  mn.pg             = MFS_BLK2PG(sb, mblk1);
-  mn.root_sz        = 0;
-  mn.ts             = ts;
-  mn.root_st_atim   = ts;
-  mn.root_st_ctim   = ts;
-  mn.root_st_mtim   = ts;
-  mn.root_mode      = 0777 | S_IFDIR;
-
-  /* Serialize. */
-
-  ser_mn(mn, buf);
-
-  ret = mfs_write_page(sb, buf, sz, MFS_BLK2PG(sb, mblk1), 0);
-  if (predict_false(ret < 0))
-    {
-      goto errout;
-    }
-  else
-    {
-      ret = OK;
-    }
-
-  ret = mfs_write_page(sb, buf, sz, MFS_BLK2PG(sb, mblk2), 0);
-  if (predict_false(ret < 0))
-    {
-      goto errout;
-    }
-  else
-    {
-      ret = OK;
-    }
-
-  mn.mblk_idx = 1;
-  MFS_MN(sb) = mn;
-  finfo("Master node written. Now at page %d, timestamp %lld.%.9ld.",
-        MFS_MN(sb).pg, (long long)MFS_MN(sb).ts.tv_sec,
-        MFS_MN(sb).ts.tv_nsec);
-
-errout:
-  return ret;
-}
-
-int mfs_mn_move(FAR struct mfs_sb_s * const sb, struct mfs_ctz_s root,
-                const mfs_t root_sz)
-{
-  int             ret          = OK;
-  struct mfs_mn_s mn;
-  const mfs_t     sz           = sizeof(struct mfs_mn_s) - sizeof(mn.pg);
-  char            buf[sz + 1];
-
-  if (MFS_MN(sb).mblk_idx == MFS_PGINBLK(sb) - 1)
-    {
-      /* TODO: Move journal. Master blocks are full. */
-    }
-
-  mn = MFS_MN(sb);
-
-  mn.root_ctz = root;
-  mn.root_sz = root_sz;
-  mn.mblk_idx++; /* TODO */
-  mn.pg++;
-
-  ser_mn(mn, buf);
-
-  ret = mfs_write_page(sb, buf, sz + 1, mn.pg, 0);
-  if (predict_false(ret < 0))
-    {
-      goto errout;
-    }
-
-  MFS_MN(sb) = mn;
-
-errout:
-  return ret;
-}
-
-int mfs_mn_sync(FAR struct mfs_sb_s *sb,
-                FAR struct mfs_path_s * const new_loc,
-                const mfs_t blk1, const mfs_t blk2, const mfs_t jrnl_blk)
-{
-  int              ret         = OK;
-  struct timespec  ts;
-  struct mfs_mn_s  mn;
-  const mfs_t      sz          = sizeof(struct mfs_mn_s) - sizeof(mn.pg);
-  char             buf[sz + 1];
-
-  mn = MFS_MN(sb);
-
-  clock_gettime(CLOCK_REALTIME, &ts);
-
-  if (mn.mblk_idx == MFS_PGINBLK(sb))
-    {
-      /* New blocks have been already allocated by the journal. */
-
-      mn.mblk_idx = 0;
-      mn.pg       = MFS_BLK2PG(sb, blk1);
-    }
-
-  mn.ts        = ts;
-  mn.root_sz   = new_loc->sz;
-  mn.root_ctz  = new_loc->ctz;
-  mn.root_mode = 0777 | S_IFDIR;
-
-  /* TODO: Root timestamps. */
-
-  /* Serialize. */
-
-  ser_mn(mn, buf);
-
-  ret = mfs_write_page(sb, buf, sz, MFS_BLK2PG(sb, blk1) + mn.mblk_idx, 0);
-  if (predict_false(ret < 0))
-    {
-      goto errout;
-    }
-
-  ret = mfs_write_page(sb, buf, sz, MFS_BLK2PG(sb, blk2) + mn.mblk_idx, 0);
-  if (predict_false(ret < 0))
-    {
-      goto errout;
-    }
-
-  mn.mblk_idx++;
-  MFS_MN(sb) = mn;
-
-errout:
-  return ret;
-}
@@ -1,263 +0,0 @@
-/****************************************************************************
- * fs/mnemofs/mnemofs_util.c
- *
- * SPDX-License-Identifier: Apache-2.0 or BSD-3-Clause
- *
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.  The
- * ASF licenses this file to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the
- * License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- * Alternatively, the contents of this file may be used under the terms of
- * the BSD-3-Clause license:
- *
- * SPDX-License-Identifier: BSD-3-Clause
- *
- * Copyright (c) 2024 Saurav Pal
- *
- * 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 of the author nor the names of its contributors may
- *    be used to endorse or promote products derived from this software
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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 "mnemofs.h"
-
-#include <sys/param.h>
-#include <stdio.h>
-
-/****************************************************************************
- * Pre-processor Definitions
- ****************************************************************************/
-
-/****************************************************************************
- * Private Types
- ****************************************************************************/
-
-/****************************************************************************
- * Private Function Prototypes
- ****************************************************************************/
-
-/****************************************************************************
- * Private Data
- ****************************************************************************/
-
-/****************************************************************************
- * Public Data
- ****************************************************************************/
-
-/****************************************************************************
- * Private Functions
- ****************************************************************************/
-
-/****************************************************************************
- * Public Functions
- ****************************************************************************/
-
-uint16_t mfs_hash(FAR const char *arr, ssize_t len)
-{
-  ssize_t  l    = 0;
-  ssize_t  r    = len - 1;
-  uint32_t hash = 0;
-
-  while (l <= r)
-    {
-      hash += arr[l] * arr[r] * (l + 1) * (r + 1);
-      l++;
-      r--;
-      hash %= (1 << MFS_HASHSZ);
-    }
-
-  finfo("Hash calculated for size %zd to be %" PRIi32, len, hash);
-
-  return hash;
-}
-
-FAR char *mfs_ser_8(const uint8_t n, FAR char * const out)
-{
-  *out = n;
-  return out + 1;
-}
-
-FAR const char *mfs_deser_8(FAR const char * const in, FAR uint8_t *n)
-{
-  *n = in[0];
-  return in + 1;
-}
-
-FAR char *mfs_ser_16(const uint16_t n, FAR char * const out)
-{
-  memcpy(out, &n, 2);
-  return out + 2;
-}
-
-FAR const char *mfs_deser_16(FAR const char * const in, FAR uint16_t *n)
-{
-  memcpy(n, in, 2);
-  return in + 2;
-}
-
-FAR char *mfs_ser_str(FAR const char * const str, const mfs_t len,
-                      FAR char * const out)
-{
-  memcpy(out, str, len);
-  return out + len;
-}
-
-FAR const char *mfs_deser_str(FAR const char * const in,
-                              FAR char * const str, const mfs_t len)
-{
-  memcpy(str, in, len);
-  str[len] = 0;
-  return in + len;
-}
-
-FAR char *mfs_ser_mfs(const mfs_t n, FAR char * const out)
-{
-  memcpy(out, &n, 4);
-  return out + 4;
-}
-
-FAR const char *mfs_deser_mfs(FAR const char * const in, FAR mfs_t * const n)
-{
-  memcpy(n, in, 4);
-  return in + 4;
-}
-
-FAR char *mfs_ser_64(const uint64_t n, FAR char * const out)
-{
-  memcpy(out, &n, 8);
-  return out + 8;
-}
-
-FAR const char *mfs_deser_64(FAR const char * const in,
-                            FAR uint64_t * const n)
-{
-  memcpy(n, in, 8);
-  return in + 8;
-}
-
-FAR char *mfs_ser_ctz(FAR const struct mfs_ctz_s * const x,
-                      FAR char * const out)
-{
-  FAR char *o = out;
-
-  o = mfs_ser_mfs(x->pg_e, o);
-  o = mfs_ser_mfs(x->idx_e, o);
-  return o;
-}
-
-FAR const char *mfs_deser_ctz(FAR const char * const in,
-                              FAR struct mfs_ctz_s * const x)
-{
-  FAR const char *i = in;
-
-  i = mfs_deser_mfs(i, &x->pg_e);
-  i = mfs_deser_mfs(i, &x->idx_e);
-  return i;
-}
-
-FAR char *mfs_ser_path(FAR const struct mfs_path_s * const x,
-                      FAR char * const out)
-{
-  FAR char *o = out;
-
-  o = mfs_ser_ctz(&x->ctz, o);
-  o = mfs_ser_mfs(x->off, o);
-  o = mfs_ser_mfs(x->sz, o);
-  return o;
-}
-
-FAR const char *mfs_deser_path(FAR const char * const in,
-                               FAR struct mfs_path_s * const x)
-{
-  FAR const char *i = in;
-
-  i = mfs_deser_ctz(i, &x->ctz);
-  i = mfs_deser_mfs(i, &x->off);
-  i = mfs_deser_mfs(i, &x->sz);
-  return i;
-}
-
-FAR char *mfs_ser_timespec(FAR const struct timespec * const x,
-                           FAR char * const out)
-{
-  FAR char *o = out;
-
-  o = mfs_ser_64(x->tv_sec, o);
-  o = mfs_ser_64(x->tv_nsec, o);
-
-  return o;
-}
-
-FAR const char *mfs_deser_timespec(FAR const char * const in,
-                                   FAR struct timespec * const x)
-{
-  uint64_t tmp;
-  FAR const char *i = in;
-
-  i = mfs_deser_64(i, &tmp);
-  x->tv_sec = tmp;
-  i = mfs_deser_64(i, &tmp);
-  x->tv_nsec = tmp;
-
-  return i;
-}
-
-mfs_t mfs_v2n(mfs_t n)
-{
-  /* https://math.stackexchange.com/a/1835555 */
-
-  return (n & (~(n - 1)));
-}
-
-mfs_t mfs_set_msb(mfs_t n)
-{
-  return 31 - mfs_clz(n);
-}
-
-bool mfs_ctz_eq(FAR const struct mfs_ctz_s * const a,
-                FAR const struct mfs_ctz_s * const b)
-{
-  return a->idx_e == b->idx_e && a->pg_e == b->pg_e;
-}
-
-bool mfs_path_eq(FAR const struct mfs_path_s * const a,
-                 FAR const struct mfs_path_s * const b)
-{
-  return mfs_ctz_eq(&a->ctz, &b->ctz) && (a->off == b->off)
-         && (a->sz == b->sz);
-}