fs/xxfs:Replace kmm with fs heap

Summary:
  1.Add configuration to allocate memory from the specified section
  2.Replace all memory operations (kmm_) in the vfs with
    fs_heap_. When FS_HEAPSIZE > 0, memory is requested for the file system by specifying a configured heap location. By default (i.e. FS_HEAPSIZE=0) fs_heap_ is equivalent to kmm_

Signed-off-by: chenrun1 <chenrun1@xiaomi.com>

fs/CMakeLists.txt

@@ -17,6 +17,12 @@
 # the License.
 #
 # ##############################################################################
+
+if(NOT "${CONFIG_FS_HEAPBUF_SECTION}" STREQUAL "")
+  target_compile_definitions(
+    fs PRIVATE FS_HEAPBUF_SECTION=${CONFIG_FS_HEAPBUF_SECTION})
+endif()
+
 nuttx_add_kernel_library(fs fs_initialize.c fs_heap.c)
 nuttx_add_subdirectory()
 target_include_directories(fs PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}

fs/Kconfig

@@ -112,13 +112,21 @@ config SENDFILE_BUFSIZE
 		Size of the I/O buffer to allocate in sendfile().  Default: 512b
 
 config FS_HEAPSIZE
-	int "Independent heap bytes used by shm/tmpfs/pseudofile"
+	int "Independent heap bytes"
 	default 0
 	depends on FS_SHMFS || FS_TMPFS || PSEUDOFS_FILE
 	---help---
 		Support for shm/tmpfs/fs_pseudofile.c ram based fs memory.
 		default 0 to use kmm directly. independent heap disabled
 
+config FS_HEAPBUF_SECTION
+	string "FS heap use Userheap section"
+	depends on FS_HEAPSIZE > 0
+	default ""
+	---help---
+		Allocated fs heap from the specified section. If not
+		specified, it will alloc from kernel heap.
+
 config FS_REFCOUNT
 	bool "File reference count"
 	default !DEFAULT_SMALL

fs/Makefile

@@ -22,6 +22,10 @@ include $(TOPDIR)/Make.defs
 
 CSRCS = fs_initialize.c fs_heap.c
 
+ifneq ($(CONFIG_FS_HEAPBUF_SECTION),"")
+  CFLAGS += ${DEFINE_PREFIX}FS_HEAPBUF_SECTION=CONFIG_FS_HEAPBUF_SECTION
+endif
+
 include inode/Make.defs
 include vfs/Make.defs
 include driver/Make.defs

fs/binfs/fs_binfs.c

@@ -41,6 +41,7 @@
 #include <nuttx/lib/builtin.h>
 
 #include "inode/inode.h"
+#include "fs_heap.h"
 
 #if !defined(CONFIG_DISABLE_MOUNTPOINT) && defined(CONFIG_FS_BINFS)
 
@@ -305,7 +306,7 @@ static int binfs_opendir(FAR struct inode *mountpt, FAR const char *relpath,
       return -ENOENT;
     }
 
-  bdir = kmm_zalloc(sizeof(*bdir));
+  bdir = fs_heap_zalloc(sizeof(*bdir));
   if (bdir == NULL)
     {
       return -ENOMEM;
@@ -330,7 +331,7 @@ static int binfs_closedir(FAR struct inode *mountpt,
                           FAR struct fs_dirent_s *dir)
 {
   DEBUGASSERT(dir);
-  kmm_free(dir);
+  fs_heap_free(dir);
   return 0;
 }
 

fs/cromfs/fs_cromfs.c

@@ -43,6 +43,7 @@
 #include <nuttx/fs/ioctl.h>
 
 #include "cromfs.h"
+#include "fs_heap.h"
 
 #if !defined(CONFIG_DISABLE_MOUNTPOINT) && defined(CONFIG_FS_CROMFS)
 
@@ -785,7 +786,7 @@ static int cromfs_open(FAR struct file *filep, FAR const char *relpath,
    * file.
    */
 
-  ff = kmm_zalloc(sizeof(struct cromfs_file_s));
+  ff = fs_heap_zalloc(sizeof(struct cromfs_file_s));
   if (ff == NULL)
     {
       return -ENOMEM;
@@ -793,10 +794,10 @@ static int cromfs_open(FAR struct file *filep, FAR const char *relpath,
 
   /* Create a file buffer to support partial sector accesses */
 
-  ff->ff_buffer = kmm_malloc(fs->cv_bsize);
+  ff->ff_buffer = fs_heap_malloc(fs->cv_bsize);
   if (!ff->ff_buffer)
     {
-      kmm_free(ff);
+      fs_heap_free(ff);
       return -ENOMEM;
     }
 
@@ -829,8 +830,8 @@ static int cromfs_close(FAR struct file *filep)
 
   /* Free all resources consumed by the opened file */
 
-  kmm_free(ff->ff_buffer);
+  fs_heap_free(ff->ff_buffer);
-  kmm_free(ff);
+  fs_heap_free(ff);
 
   return OK;
 }
@@ -1118,7 +1119,7 @@ static int cromfs_dup(FAR const struct file *oldp, FAR struct file *newp)
    * same node.
    */
 
-  newff = kmm_zalloc(sizeof(struct cromfs_file_s));
+  newff = fs_heap_zalloc(sizeof(struct cromfs_file_s));
   if (newff == NULL)
     {
       return -ENOMEM;
@@ -1126,10 +1127,10 @@ static int cromfs_dup(FAR const struct file *oldp, FAR struct file *newp)
 
   /* Create a file buffer to support partial sector accesses */
 
-  newff->ff_buffer = kmm_malloc(fs->cv_bsize);
+  newff->ff_buffer = fs_heap_malloc(fs->cv_bsize);
   if (newff->ff_buffer == NULL)
     {
-      kmm_free(newff);
+      fs_heap_free(newff);
       return -ENOMEM;
     }
 
@@ -1236,7 +1237,7 @@ static int cromfs_opendir(FAR struct inode *mountpt, FAR const char *relpath,
       return -ENOTDIR;
     }
 
-  cdir = kmm_zalloc(sizeof(*cdir));
+  cdir = fs_heap_zalloc(sizeof(*cdir));
   if (cdir == NULL)
     {
       return -ENOMEM;
@@ -1261,7 +1262,7 @@ static int cromfs_closedir(FAR struct inode *mountpt,
                            FAR struct fs_dirent_s *dir)
 {
   DEBUGASSERT(mountpt != NULL);
-  kmm_free(dir);
+  fs_heap_free(dir);
   return 0;
 }
 

fs/driver/fs_blockpartition.c

@@ -35,6 +35,7 @@
 
 #include "driver/driver.h"
 #include "inode/inode.h"
+#include "fs_heap.h"
 
 /****************************************************************************
  * Private Types
@@ -284,7 +285,7 @@ static int part_unlink(FAR struct inode *inode)
   FAR struct inode *parent = dev->parent;
 
   inode_release(parent);
-  kmm_free(dev);
+  fs_heap_free(dev);
 
   return OK;
 }
@@ -332,7 +333,7 @@ int register_partition_with_inode(FAR const char *partition,
 
   /* Allocate a partition device structure */
 
-  dev = kmm_zalloc(sizeof(*dev));
+  dev = fs_heap_zalloc(sizeof(*dev));
   if (dev == NULL)
     {
       return -ENOMEM;
@@ -365,7 +366,7 @@ int register_partition_with_inode(FAR const char *partition,
 
 errout_free:
   inode_release(parent);
-  kmm_free(dev);
+  fs_heap_free(dev);
   return ret;
 }
 

fs/fat/fs_fat32.c

@@ -318,7 +318,7 @@ static int fat_open(FAR struct file *filep, FAR const char *relpath,
    * file.
    */
 
-  ff = kmm_zalloc(sizeof(struct fat_file_s));
+  ff = fs_heap_zalloc(sizeof(struct fat_file_s));
   if (!ff)
     {
       ret = -ENOMEM;
@@ -379,7 +379,7 @@ static int fat_open(FAR struct file *filep, FAR const char *relpath,
       off_t offset = fat_seek(filep, ff->ff_size, SEEK_SET);
       if (offset < 0)
         {
-          kmm_free(ff);
+          fs_heap_free(ff);
           return (int)offset;
         }
     }
@@ -391,7 +391,7 @@ static int fat_open(FAR struct file *filep, FAR const char *relpath,
    */
 
 errout_with_struct:
-  kmm_free(ff);
+  fs_heap_free(ff);
 
 errout_with_lock:
   nxmutex_unlock(&fs->fs_lock);
@@ -469,7 +469,7 @@ static int fat_close(FAR struct file *filep)
 
   /* Then free the file structure itself. */
 
-  kmm_free(ff);
+  fs_heap_free(ff);
   filep->f_priv = NULL;
   return ret;
 }
@@ -504,7 +504,7 @@ static int fat_zero_cluster(FAR struct fat_mountpt_s *fs, int cluster,
   off_t end_sec = sector + DIV_ROUND_UP(end, fs->fs_hwsectorsize);
   int ret;
 
-  buf = kmm_malloc(fs->fs_hwsectorsize);
+  buf = fs_heap_malloc(fs->fs_hwsectorsize);
   if (!buf)
     {
       return -ENOMEM;
@@ -543,7 +543,7 @@ static int fat_zero_cluster(FAR struct fat_mountpt_s *fs, int cluster,
   ret = OK;
 
 out:
-  kmm_free(buf);
+  fs_heap_free(buf);
 
   return ret;
 }
@@ -1549,7 +1549,7 @@ static int fat_dup(FAR const struct file *oldp, FAR struct file *newp)
    * dup'ed file.
    */
 
-  newff = kmm_malloc(sizeof(struct fat_file_s));
+  newff = fs_heap_malloc(sizeof(struct fat_file_s));
   if (!newff)
     {
       ret = -ENOMEM;
@@ -1616,7 +1616,7 @@ static int fat_dup(FAR const struct file *oldp, FAR struct file *newp)
    */
 
 errout_with_struct:
-  kmm_free(newff);
+  fs_heap_free(newff);
 
 errout_with_lock:
   nxmutex_unlock(&fs->fs_lock);
@@ -1647,7 +1647,7 @@ static int fat_opendir(FAR struct inode *mountpt, FAR const char *relpath,
 
   fs = mountpt->i_private;
 
-  fdir = kmm_zalloc(sizeof(struct fat_dirent_s));
+  fdir = fs_heap_zalloc(sizeof(struct fat_dirent_s));
   if (fdir == NULL)
     {
       return -ENOMEM;
@@ -1725,7 +1725,7 @@ errout_with_lock:
   nxmutex_unlock(&fs->fs_lock);
 
 errout_with_fdir:
-  kmm_free(fdir);
+  fs_heap_free(fdir);
   return ret;
 }
 
@@ -1740,7 +1740,7 @@ static int fat_closedir(FAR struct inode *mountpt,
                         FAR struct fs_dirent_s *dir)
 {
   DEBUGASSERT(dir);
-  kmm_free(dir);
+  fs_heap_free(dir);
   return 0;
 }
 
@@ -2230,7 +2230,7 @@ static int fat_bind(FAR struct inode *blkdriver, FAR const void *data,
 
   /* Create an instance of the mountpt state structure */
 
-  fs = kmm_zalloc(sizeof(struct fat_mountpt_s));
+  fs = fs_heap_zalloc(sizeof(struct fat_mountpt_s));
   if (!fs)
     {
       return -ENOMEM;
@@ -2252,7 +2252,7 @@ static int fat_bind(FAR struct inode *blkdriver, FAR const void *data,
   if (ret != 0)
     {
       nxmutex_destroy(&fs->fs_lock);
-      kmm_free(fs);
+      fs_heap_free(fs);
       return ret;
     }
 
@@ -2354,7 +2354,7 @@ static int fat_unbind(FAR void *handle, FAR struct inode **blkdriver,
     }
 
   nxmutex_destroy(&fs->fs_lock);
-  kmm_free(fs);
+  fs_heap_free(fs);
   return OK;
 }
 

fs/fat/fs_fat32.h

@@ -35,6 +35,8 @@
 #include <nuttx/kmalloc.h>
 #include <nuttx/mutex.h>
 
+#include "fs_heap.h"
+
 /****************************************************************************
  * Pre-processor Definitions
  ****************************************************************************/
@@ -845,8 +847,8 @@
 #  define fat_io_alloc(s)  fat_dma_alloc(s)
 #  define fat_io_free(m,s) fat_dma_free(m,s)
 #else
-#  define fat_io_alloc(s)  kmm_malloc(s)
+#  define fat_io_alloc(s)  fs_heap_malloc(s)
-#  define fat_io_free(m,s) kmm_free(m)
+#  define fat_io_free(m,s) fs_heap_free(m)
 #endif
 
 /****************************************************************************

fs/fs_heap.c

@@ -38,7 +38,12 @@ static FAR struct mm_heap_s *g_fs_heap;
 
 void fs_heap_initialize(void)
 {
+#ifdef FS_HEAPBUF_SECTION
+  static uint8_t buf[CONFIG_FS_HEAPSIZE] locate_data(FS_HEAPBUF_SECTION);
+#else
   FAR void *buf = kmm_malloc(CONFIG_FS_HEAPSIZE);
+#endif
+
   DEBUGASSERT(buf != NULL);
   g_fs_heap = mm_initialize("heapfs", buf, CONFIG_FS_HEAPSIZE);
 }
@@ -48,6 +53,11 @@ FAR void *fs_heap_zalloc(size_t size)
   return mm_zalloc(g_fs_heap, size);
 }
 
+FAR void *fs_heap_malloc(size_t size)
+{
+  return mm_malloc(g_fs_heap, size);
+}
+
 size_t fs_heap_malloc_size(FAR void *mem)
 {
   return mm_malloc_size(g_fs_heap, mem);

fs/fs_heap.h

@@ -36,12 +36,14 @@
 #if defined(CONFIG_FS_HEAPSIZE) && CONFIG_FS_HEAPSIZE > 0
 void      fs_heap_initialize(void);
 FAR void *fs_heap_zalloc(size_t size);
+FAR void *fs_heap_malloc(size_t size);
 size_t    fs_heap_malloc_size(FAR void *mem);
 FAR void *fs_heap_realloc(FAR void *oldmem, size_t size);
 void      fs_heap_free(FAR void *mem);
 #else
 #  define fs_heap_initialize()
 #  define fs_heap_zalloc       kmm_zalloc
+#  define fs_heap_malloc       kmm_malloc
 #  define fs_heap_malloc_size  kmm_malloc_size
 #  define fs_heap_realloc      kmm_realloc
 #  define fs_heap_free         kmm_free

fs/hostfs/hostfs.c

@@ -45,6 +45,7 @@
 
 #include "inode/inode.h"
 #include "hostfs.h"
+#include "fs_heap.h"
 
 /****************************************************************************
  * Pre-processor Definitions
@@ -273,7 +274,7 @@ static int hostfs_open(FAR struct file *filep, FAR const char *relpath,
   /* Allocate memory for the open file */
 
   len = strlen(relpath);
-  hf = kmm_malloc(sizeof(*hf) + len);
+  hf = fs_heap_malloc(sizeof(*hf) + len);
   if (hf == NULL)
     {
       ret = -ENOMEM;
@@ -332,7 +333,7 @@ static int hostfs_open(FAR struct file *filep, FAR const char *relpath,
   goto errout_with_lock;
 
 errout_with_buffer:
-  kmm_free(hf);
+  fs_heap_free(hf);
 
 errout_with_lock:
   nxmutex_unlock(&g_lock);
@@ -426,7 +427,7 @@ static int hostfs_close(FAR struct file *filep)
   /* Now free the pointer */
 
   filep->f_priv = NULL;
-  kmm_free(hf);
+  fs_heap_free(hf);
 
 okout:
   nxmutex_unlock(&g_lock);
@@ -857,7 +858,7 @@ static int hostfs_opendir(FAR struct inode *mountpt, FAR const char *relpath,
   /* Recover our private data from the inode instance */
 
   fs = mountpt->i_private;
-  hdir = kmm_zalloc(sizeof(struct hostfs_dir_s));
+  hdir = fs_heap_zalloc(sizeof(struct hostfs_dir_s));
   if (hdir == NULL)
     {
       return -ENOMEM;
@@ -892,7 +893,7 @@ errout_with_lock:
   nxmutex_unlock(&g_lock);
 
 errout_with_hdir:
-  kmm_free(hdir);
+  fs_heap_free(hdir);
   return ret;
 }
 
@@ -930,7 +931,7 @@ static int hostfs_closedir(FAR struct inode *mountpt,
   host_closedir(hdir->dir);
 
   nxmutex_unlock(&g_lock);
-  kmm_free(hdir);
+  fs_heap_free(hdir);
   return OK;
 }
 
@@ -1040,7 +1041,7 @@ static int hostfs_bind(FAR struct inode *blkdriver, FAR const void *data,
   /* Create an instance of the mountpt state structure */
 
   fs = (FAR struct hostfs_mountpt_s *)
-    kmm_zalloc(sizeof(struct hostfs_mountpt_s));
+    fs_heap_zalloc(sizeof(struct hostfs_mountpt_s));
 
   if (fs == NULL)
     {
@@ -1054,7 +1055,7 @@ static int hostfs_bind(FAR struct inode *blkdriver, FAR const void *data,
   options = strdup(data);
   if (!options)
     {
-      kmm_free(fs);
+      fs_heap_free(fs);
       return -ENOMEM;
     }
 
@@ -1076,7 +1077,7 @@ static int hostfs_bind(FAR struct inode *blkdriver, FAR const void *data,
   ret = nxmutex_lock(&g_lock);
   if (ret < 0)
     {
-      kmm_free(fs);
+      fs_heap_free(fs);
       return ret;
     }
 
@@ -1150,7 +1151,7 @@ static int hostfs_unbind(FAR void *handle, FAR struct inode **blkdriver,
     }
 
   nxmutex_unlock(&g_lock);
-  kmm_free(fs);
+  fs_heap_free(fs);
   return ret;
 }
 

fs/inode/fs_files.c

@@ -53,6 +53,7 @@
 
 #include "sched/sched.h"
 #include "inode/inode.h"
+#include "fs_heap.h"
 
 /****************************************************************************
  * Private Functions
@@ -136,7 +137,7 @@ static int files_extend(FAR struct filelist *list, size_t row)
       return -EMFILE;
     }
 
-  files = kmm_malloc(sizeof(FAR struct file *) * row);
+  files = fs_heap_malloc(sizeof(FAR struct file *) * row);
   DEBUGASSERT(files);
   if (files == NULL)
     {
@@ -146,16 +147,16 @@ static int files_extend(FAR struct filelist *list, size_t row)
   i = orig_rows;
   do
     {
-      files[i] = kmm_zalloc(sizeof(struct file) *
+      files[i] = fs_heap_zalloc(sizeof(struct file) *
                             CONFIG_NFILE_DESCRIPTORS_PER_BLOCK);
       if (files[i] == NULL)
         {
           while (--i >= orig_rows)
             {
-              kmm_free(files[i]);
+              fs_heap_free(files[i]);
             }
 
-          kmm_free(files);
+          fs_heap_free(files);
           return -ENFILE;
         }
     }
@@ -174,10 +175,10 @@ static int files_extend(FAR struct filelist *list, size_t row)
 
       for (j = orig_rows; j < i; j++)
         {
-          kmm_free(files[j]);
+          fs_heap_free(files[j]);
         }
 
-      kmm_free(files);
+      fs_heap_free(files);
 
       return OK;
     }
@@ -196,7 +197,7 @@ static int files_extend(FAR struct filelist *list, size_t row)
 
   if (tmp != NULL && tmp != &list->fl_prefile)
     {
-      kmm_free(tmp);
+      fs_heap_free(tmp);
     }
 
   return OK;
@@ -485,13 +486,13 @@ void files_putlist(FAR struct filelist *list)
 
       if (i != 0)
         {
-          kmm_free(list->fl_files[i]);
+          fs_heap_free(list->fl_files[i]);
         }
     }
 
   if (list->fl_files != &list->fl_prefile)
     {
-      kmm_free(list->fl_files);
+      fs_heap_free(list->fl_files);
     }
 }
 

fs/inode/fs_foreachinode.c

@@ -33,6 +33,7 @@
 #include <nuttx/fs/fs.h>
 
 #include "inode/inode.h"
+#include "fs_heap.h"
 
 /****************************************************************************
  * Pre-processor Definitions
@@ -170,7 +171,7 @@ int foreach_inode(foreach_inode_t handler, FAR void *arg)
 
   /* Allocate the mountpoint info structure */
 
-  info = kmm_malloc(sizeof(struct inode_path_s));
+  info = fs_heap_malloc(sizeof(struct inode_path_s));
   if (!info)
     {
       return -ENOMEM;
@@ -193,7 +194,7 @@ int foreach_inode(foreach_inode_t handler, FAR void *arg)
 
   /* Free the info structure and return the result */
 
-  kmm_free(info);
+  fs_heap_free(info);
   return ret;
 
 #else

fs/inode/fs_inodefree.c

@@ -31,6 +31,7 @@
 #include <nuttx/fs/fs.h>
 
 #include "inode/inode.h"
+#include "fs_heap.h"
 
 /****************************************************************************
  * Public Functions
@@ -69,10 +70,10 @@ void inode_free(FAR struct inode *node)
 
       if (INODE_IS_SOFTLINK(node) && node->u.i_link != NULL)
         {
-          kmm_free(node->u.i_link);
+          fs_heap_free(node->u.i_link);
         }
 #endif
 
-      kmm_free(node);
+      fs_heap_free(node);
     }
 }

fs/inode/fs_inodereserve.c

@@ -31,6 +31,7 @@
 #include <nuttx/fs/fs.h>
 
 #include "inode/inode.h"
+#include "fs_heap.h"
 
 /****************************************************************************
  * Private Data
@@ -81,7 +82,7 @@ static FAR struct inode *inode_alloc(FAR const char *name, mode_t mode)
   int namelen;
 
   namelen = inode_namelen(name);
-  node    = kmm_zalloc(FSNODE_SIZE(namelen));
+  node    = fs_heap_zalloc(FSNODE_SIZE(namelen));
   if (node)
     {
       node->i_ino   = g_ino++;

fs/littlefs/lfs_util.patch

@@ -1,10 +1,11 @@
 --- ./littlefs/littlefs/lfs_util.h	2022-11-11 03:32:30.000000000 +1100
 +++ ./littlefs/littlefs/lfs_util.h	2023-04-21 12:25:27.987084276 +1000
-@@ -28,6 +28,7 @@
+@@ -28,6 +28,8 @@
 
  #ifndef LFS_NO_MALLOC
  #include <stdlib.h>
 +#include <nuttx/mm/mm.h>
++#include "fs_heap.h"
  #endif
  #ifndef LFS_NO_ASSERT
  #include <assert.h>
@@ -13,7 +14,7 @@
  static inline void *lfs_malloc(size_t size) {
  #ifndef LFS_NO_MALLOC
 -    return malloc(size);
-+    return kmm_malloc(size);
++    return fs_heap_malloc(size);
  #else
      (void)size;
      return NULL;
@@ -22,7 +23,7 @@
  static inline void lfs_free(void *p) {
  #ifndef LFS_NO_MALLOC
 -    free(p);
-+    kmm_free(p);
++    fs_heap_free(p);
  #else
      (void)p;
  #endif

fs/littlefs/lfs_vfs.c

@@ -40,6 +40,7 @@
 #include "inode/inode.h"
 #include "littlefs/lfs.h"
 #include "littlefs/lfs_util.h"
+#include "fs_heap.h"
 
 /****************************************************************************
  * Pre-processor Definitions
@@ -298,7 +299,7 @@ static int littlefs_open(FAR struct file *filep, FAR const char *relpath,
 
   /* Allocate memory for the open file */
 
-  priv = kmm_malloc(sizeof(*priv));
+  priv = fs_heap_malloc(sizeof(*priv));
   if (priv == NULL)
     {
       return -ENOMEM;
@@ -361,7 +362,7 @@ errout_with_file:
 errout:
   nxmutex_unlock(&fs->lock);
 errlock:
-  kmm_free(priv);
+  fs_heap_free(priv);
   return ret;
 }
 
@@ -398,7 +399,7 @@ static int littlefs_close(FAR struct file *filep)
   nxmutex_unlock(&fs->lock);
   if (priv->refs <= 0)
     {
-      kmm_free(priv);
+      fs_heap_free(priv);
     }
 
   return ret;
@@ -780,7 +781,7 @@ static int littlefs_opendir(FAR struct inode *mountpt,
 
   /* Allocate memory for the open directory */
 
-  ldir = kmm_malloc(sizeof(*ldir));
+  ldir = fs_heap_malloc(sizeof(*ldir));
   if (ldir == NULL)
     {
       return -ENOMEM;
@@ -809,7 +810,7 @@ static int littlefs_opendir(FAR struct inode *mountpt,
 errout:
   nxmutex_unlock(&fs->lock);
 errlock:
-  kmm_free(ldir);
+  fs_heap_free(ldir);
   return ret;
 }
 
@@ -843,7 +844,7 @@ static int littlefs_closedir(FAR struct inode *mountpt,
   lfs_dir_close(&fs->lfs, &ldir->dir);
   nxmutex_unlock(&fs->lock);
 
-  kmm_free(ldir);
+  fs_heap_free(ldir);
   return OK;
 }
 
@@ -1070,7 +1071,7 @@ static int littlefs_bind(FAR struct inode *driver, FAR const void *data,
 
   /* Create an instance of the mountpt state structure */
 
-  fs = kmm_zalloc(sizeof(*fs));
+  fs = fs_heap_zalloc(sizeof(*fs));
   if (!fs)
     {
       ret = -ENOMEM;
@@ -1200,7 +1201,7 @@ static int littlefs_bind(FAR struct inode *driver, FAR const void *data,
 
 errout_with_fs:
   nxmutex_destroy(&fs->lock);
-  kmm_free(fs);
+  fs_heap_free(fs);
 errout_with_block:
   if (INODE_IS_BLOCK(driver) && driver->u.i_bops->close)
     {
@@ -1259,7 +1260,7 @@ static int littlefs_unbind(FAR void *handle, FAR struct inode **driver,
       /* Release the mountpoint private data */
 
       nxmutex_destroy(&fs->lock);
-      kmm_free(fs);
+      fs_heap_free(fs);
     }
 
   return ret;

fs/mmap/fs_anonmap.c

@@ -30,6 +30,7 @@
 
 #include "fs_anonmap.h"
 #include "sched/sched.h"
+#include "fs_heap.h"
 
 /****************************************************************************
  * Private Functions
@@ -77,7 +78,7 @@ static int unmap_anonymous(FAR struct task_group_s *group,
 
       if (kernel)
         {
-          kmm_free(entry->vaddr);
+          fs_heap_free(entry->vaddr);
         }
       else
         {
@@ -97,7 +98,7 @@ static int unmap_anonymous(FAR struct task_group_s *group,
     {
       if (kernel)
         {
-          newaddr = kmm_realloc(entry->vaddr, length);
+          newaddr = fs_heap_realloc(entry->vaddr, length);
         }
       else
         {
@@ -127,7 +128,7 @@ int map_anonymous(FAR struct mm_map_entry_s *entry, bool kernel)
    */
 
   entry->vaddr = kernel ?
-    kmm_zalloc(entry->length) : kumm_zalloc(entry->length);
+    fs_heap_zalloc(entry->length) : kumm_zalloc(entry->length);
   if (entry->vaddr == NULL)
     {
       ferr("ERROR: kumm_alloc() failed, enable DEBUG_MM for info!\n");
@@ -142,7 +143,7 @@ int map_anonymous(FAR struct mm_map_entry_s *entry, bool kernel)
     {
       if (kernel)
         {
-          kmm_free(entry->vaddr);
+          fs_heap_free(entry->vaddr);
         }
       else
         {

fs/mmap/fs_anonmap.h

@@ -42,7 +42,7 @@
  *
  * Input Parameters:
  *   map     Input struct containing user request
- *   kernel  kmm_zalloc or kumm_zalloc
+ *   kernel  fs_heap_zalloc or kumm_zalloc
  *
  * Returned Value:
  *   On success returns 0. Otherwise negated errno is returned appropriately.

fs/mmap/fs_rammap.c

@@ -39,6 +39,7 @@
 
 #include "fs_rammap.h"
 #include "sched/sched.h"
+#include "fs_heap.h"
 
 /****************************************************************************
  * Public Data
@@ -165,7 +166,7 @@ static int unmap_rammap(FAR struct task_group_s *group,
 
       if (type == MAP_KERNEL)
         {
-          kmm_free(entry->vaddr);
+          fs_heap_free(entry->vaddr);
         }
       else if (type == MAP_USER)
         {
@@ -187,7 +188,7 @@ static int unmap_rammap(FAR struct task_group_s *group,
     {
       if (type == MAP_KERNEL)
         {
-          newaddr = kmm_realloc(entry->vaddr, length);
+          newaddr = fs_heap_realloc(entry->vaddr, length);
         }
       else if (type == MAP_USER)
         {
@@ -216,7 +217,7 @@ static int unmap_rammap(FAR struct task_group_s *group,
  *   filep   file descriptor of the backing file -- required.
  *   entry   mmap entry information.
  *           field offset and length must be initialized correctly.
- *   type    kmm_zalloc or kumm_zalloc or xip_base
+ *   type    fs_heap_zalloc or kumm_zalloc or xip_base
  *
  * Returned Value:
  *  On success, rammap returns 0 and entry->vaddr points to memory mapped.
@@ -262,7 +263,8 @@ int rammap(FAR struct file *filep, FAR struct mm_map_entry_s *entry,
 
   /* Allocate a region of memory of the specified size */
 
-  rdbuffer = type == MAP_KERNEL ? kmm_malloc(length) : kumm_malloc(length);
+  rdbuffer = type == MAP_KERNEL ? fs_heap_malloc(length)
+                                : kumm_malloc(length);
   if (!rdbuffer)
     {
       ferr("ERROR: Region allocation failed, length: %zu\n", length);
@@ -344,7 +346,7 @@ out:
 errout_with_region:
   if (type == MAP_KERNEL)
     {
-      kmm_free(entry->vaddr);
+      fs_heap_free(entry->vaddr);
     }
   else if (type == MAP_USER)
     {

fs/mmap/fs_rammap.h

@@ -81,7 +81,7 @@ enum mm_map_type_e
  *   length  The length of the mapping.  For exception #1 above, this length
  *           ignored:  The entire underlying media is always accessible.
  *   offset  The offset into the file to map
- *   type    kmm_zalloc or kumm_zalloc or xip_base
+ *   type    fs_heap_zalloc or kumm_zalloc or xip_base
  *
  * Returned Value:
  *   On success rammmap returns 0. Otherwise errno is returned appropriately.

fs/mnemofs/mnemofs.c

@@ -97,6 +97,7 @@
 #include <sys/statfs.h>
 
 #include "mnemofs.h"
+#include "fs_heap.h"
 
 /****************************************************************************
  * Pre-processor Definitions
@@ -272,14 +273,14 @@ static int mnemofs_open(FAR struct file *filep, FAR const char *relpath,
 
   finfo("Lock Acquired.");
 
-  f     = kmm_zalloc(sizeof(*f));
+  f     = fs_heap_zalloc(sizeof(*f));
   if (predict_false(f == NULL))
     {
       ret = -ENOMEM;
       goto errout_with_lock;
     }
 
-  fcom  = kmm_zalloc(sizeof(*fcom));
+  fcom  = fs_heap_zalloc(sizeof(*fcom));
   if (predict_false(fcom == NULL))
     {
       ret = -ENOMEM;
@@ -405,10 +406,10 @@ errout_with_dirent:
     }
 
 errout_with_fcom:
-  kmm_free(fcom);
+  fs_heap_free(fcom);
 
 errout_with_f:
-  kmm_free(f);
+  fs_heap_free(f);
 
 errout_with_lock:
   nxmutex_unlock(&MFS_LOCK(sb));
@@ -478,8 +479,8 @@ static int mnemofs_close(FAR struct file *filep)
           goto errout_with_lock;
         }
 
-      kmm_free(f->com->path);
+      fs_heap_free(f->com->path);
-      kmm_free(f->com);
+      fs_heap_free(f->com);
 
       finfo("Open file structure freed.");
 
@@ -492,7 +493,7 @@ static int mnemofs_close(FAR struct file *filep)
 
 errout_with_fcom:
   list_delete(&f->list);
-  kmm_free(f);
+  fs_heap_free(f);
   filep->f_priv = NULL;
 
   finfo("File entry removed from the open files list.");
@@ -1005,7 +1006,7 @@ static int mnemofs_dup(FAR const struct file *oldp, FAR struct file *newp)
   of    = oldp->f_priv;
   DEBUGASSERT(of != NULL);
 
-  nf    = kmm_zalloc(sizeof(*nf));
+  nf    = fs_heap_zalloc(sizeof(*nf));
   if (predict_false(nf == NULL))
     {
       finfo("No memory left.");
@@ -1037,7 +1038,7 @@ static int mnemofs_dup(FAR const struct file *oldp, FAR struct file *newp)
   return ret;
 
 errout_with_nf:
-  kmm_free(nf);
+  fs_heap_free(nf);
 
 errout_with_lock:
   nxmutex_unlock(&MFS_LOCK(sb));
@@ -1192,14 +1193,14 @@ static int mnemofs_opendir(FAR struct inode *mountpt,
       goto errout_with_path;
     }
 
-  pitr     = kmm_zalloc(sizeof(*pitr));
+  pitr     = fs_heap_zalloc(sizeof(*pitr));
   if (predict_false(pitr == NULL))
     {
       ret  = -ENOMEM;
       goto errout_with_path;
     }
 
-  fsdirent = kmm_zalloc(sizeof(*fsdirent));
+  fsdirent = fs_heap_zalloc(sizeof(*fsdirent));
   if (predict_false(fsdirent == NULL))
     {
       ret  = -ENOMEM;
@@ -1228,10 +1229,10 @@ static int mnemofs_opendir(FAR struct inode *mountpt,
   return ret;
 
 errout_with_fsdirent:
-  kmm_free(fsdirent);
+  fs_heap_free(fsdirent);
 
 errout_with_pitr:
-  kmm_free(pitr);
+  fs_heap_free(pitr);
 
 errout_with_path:
   mfs_free_patharr(path);
@@ -1270,8 +1271,8 @@ static int mnemofs_closedir(FAR struct inode *mountpt,
 
   mfs_free_patharr(fsdirent->path);
   mfs_pitr_free(fsdirent->pitr);
-  kmm_free(fsdirent->pitr);
+  fs_heap_free(fsdirent->pitr);
-  kmm_free(fsdirent);
+  fs_heap_free(fsdirent);
   return OK;
 }
 
@@ -1492,7 +1493,7 @@ static int mnemofs_bind(FAR struct inode *driver, FAR const void *data,
 
   memset(buf, 0, 8);
 
-  sb = kmm_zalloc(sizeof(*sb));
+  sb = fs_heap_zalloc(sizeof(*sb));
   if (!sb)
     {
       ret = -ENOMEM;
@@ -1552,7 +1553,7 @@ static int mnemofs_bind(FAR struct inode *driver, FAR const void *data,
 
   list_initialize(&MFS_OFILES(sb));
 
-  sb->rw_buf        = kmm_zalloc(MFS_PGSZ(sb));
+  sb->rw_buf        = fs_heap_zalloc(MFS_PGSZ(sb));
   if (predict_false(sb->rw_buf == NULL))
     {
       goto errout_with_lock;
@@ -1653,14 +1654,14 @@ static int mnemofs_bind(FAR struct inode *driver, FAR const void *data,
   return ret;
 
 errout_with_rwbuf:
-  kmm_free(sb->rw_buf);
+  fs_heap_free(sb->rw_buf);
 
 errout_with_lock:
   nxmutex_unlock(&MFS_LOCK(sb));
   finfo("Lock released.");
 
 errout_with_sb:
-  kmm_free(sb);
+  fs_heap_free(sb);
 
 errout:
   finfo("Mnemofs bind exited with %d.", ret);
@@ -1700,8 +1701,8 @@ static int mnemofs_unbind(FAR void *handle, FAR struct inode **driver,
   mfs_jrnl_free(sb);
   mfs_ba_free(sb);
 
-  kmm_free(sb->rw_buf);
+  fs_heap_free(sb->rw_buf);
-  kmm_free(sb);
+  fs_heap_free(sb);
 
   finfo("Successfully unmounted mnemofs!");
   return OK;

fs/mnemofs/mnemofs_blkalloc.c

@@ -86,6 +86,7 @@
 #include <stdlib.h>
 
 #include "mnemofs.h"
+#include "fs_heap.h"
 
 /****************************************************************************
  * Pre-processor Definitions
@@ -307,7 +308,7 @@ int mfs_ba_fmt(FAR struct mfs_sb_s * const sb)
 
   /* MFS_BA(sb).k_del_elemsz = ((log + 7) & (-8)) / 8; */
 
-  MFS_BA(sb).k_del = kmm_zalloc(sizeof(size_t) * MFS_NBLKS(sb));
+  MFS_BA(sb).k_del = fs_heap_zalloc(sizeof(size_t) * MFS_NBLKS(sb));
   if (predict_false(MFS_BA(sb).k_del == NULL))
     {
       ret = -ENOMEM;
@@ -316,7 +317,7 @@ int mfs_ba_fmt(FAR struct mfs_sb_s * const sb)
 
   MFS_BA(sb).n_bmap_upgs = MFS_UPPER8(MFS_NPGS(sb));
 
-  MFS_BA(sb).bmap_upgs = kmm_zalloc(MFS_BA(sb).n_bmap_upgs);
+  MFS_BA(sb).bmap_upgs = fs_heap_zalloc(MFS_BA(sb).n_bmap_upgs);
   if (predict_false(MFS_BA(sb).bmap_upgs == NULL))
     {
       ret = -ENOMEM;
@@ -330,7 +331,7 @@ int mfs_ba_fmt(FAR struct mfs_sb_s * const sb)
   return ret;
 
 errout_with_k_del:
-  kmm_free(MFS_BA(sb).k_del);
+  fs_heap_free(MFS_BA(sb).k_del);
 
 errout:
   return ret;
@@ -367,8 +368,8 @@ errout:
 
 void mfs_ba_free(FAR struct mfs_sb_s * const sb)
 {
-  kmm_free(MFS_BA(sb).k_del);
+  fs_heap_free(MFS_BA(sb).k_del);
-  kmm_free(MFS_BA(sb).bmap_upgs);
+  fs_heap_free(MFS_BA(sb).bmap_upgs);
 
   finfo("Block Allocator Freed.");
 }

fs/mnemofs/mnemofs_ctz.c

@@ -102,6 +102,7 @@
 #include <sys/stat.h>
 
 #include "mnemofs.h"
+#include "fs_heap.h"
 
 /****************************************************************************
  * Pre-processor Definitions
@@ -452,7 +453,7 @@ int mfs_ctz_wrtnode(FAR struct mfs_sb_s * const sb,
 
   /* So, till cur_idx - 1, the CTZ blocks are common. */
 
-  buf = kmm_zalloc(MFS_PGSZ(sb));
+  buf = fs_heap_zalloc(MFS_PGSZ(sb));
   if (predict_false(buf == NULL))
     {
       ret = -ENOMEM;
@@ -595,7 +596,7 @@ int mfs_ctz_wrtnode(FAR struct mfs_sb_s * const sb,
     }
 
 errout_with_buf:
-  kmm_free(buf);
+  fs_heap_free(buf);
 
 errout:
   return ret;

fs/mnemofs/mnemofs_fsobj.c

@@ -67,6 +67,7 @@
 #include <sys/stat.h>
 
 #include "mnemofs.h"
+#include "fs_heap.h"
 
 /****************************************************************************
  * Pre-processor Definitions
@@ -324,7 +325,7 @@ int pitr_traverse(FAR struct mfs_sb_s *sb, FAR struct mfs_path_s *path,
     {
       *cap = (*cap * 3) / 2; /* Don't want to double it for memory. */
 
-      path = kmm_realloc(path, (*cap) * sizeof(struct mfs_path_s));
+      path = fs_heap_realloc(path, (*cap) * sizeof(struct mfs_path_s));
       if (predict_false(path == NULL))
         {
           ret = -ENOMEM;
@@ -421,7 +422,7 @@ bool mfs_obj_isempty(FAR struct mfs_sb_s * const sb,
 
 void mfs_free_dirent(FAR struct mfs_dirent_s *dirent)
 {
-  kmm_free(dirent);
+  fs_heap_free(dirent);
 
   finfo("Dirent freed.");
 }
@@ -601,7 +602,7 @@ int mfs_pitr_readdirent(FAR const struct mfs_sb_s * const sb,
   *dirent = NULL;
   memset(rd, 0, len);
 
-  d = kmm_zalloc(len);
+  d = fs_heap_zalloc(len);
   if (predict_false(d == NULL))
     {
       ret = -ENOMEM;
@@ -637,7 +638,7 @@ int mfs_pitr_readdirent(FAR const struct mfs_sb_s * const sb,
     }
 
   sz  = MFS_DIRENTSZ(d);
-  tmp = kmm_realloc(d, sz);
+  tmp = fs_heap_realloc(d, sz);
   if (predict_true(tmp != NULL))
     {
       d = tmp;
@@ -653,7 +654,7 @@ int mfs_pitr_readdirent(FAR const struct mfs_sb_s * const sb,
   return ret;
 
 errout_with_d:
-  kmm_free(d);
+  fs_heap_free(d);
 
   if (ret < 0)
     {
@@ -713,7 +714,7 @@ static int search_ctz_by_name(FAR const struct mfs_sb_s * const sb,
     {
       DEBUGASSERT(namelen == 0);
 
-      nd = kmm_zalloc(sizeof(struct mfs_dirent_s));
+      nd = fs_heap_zalloc(sizeof(struct mfs_dirent_s));
       if (predict_false(nd == NULL))
         {
           ret = -ENOMEM;
@@ -810,7 +811,7 @@ int mfs_get_patharr(FAR const struct mfs_sb_s * const sb,
 
   *path  = NULL;
   n_objs = nobjs_in_path(relpath);
-  np     = kmm_zalloc(n_objs * sizeof(struct mfs_path_s));
+  np     = fs_heap_zalloc(n_objs * sizeof(struct mfs_path_s));
   if (predict_false(np == NULL))
     {
       ret = -ENOMEM;
@@ -921,7 +922,7 @@ errout:
 
 void mfs_free_patharr(FAR struct mfs_path_s *path)
 {
-  kmm_free(path);
+  fs_heap_free(path);
 }
 
 void mfs_pitr_reset(FAR struct mfs_pitr_s * const pitr)
@@ -988,7 +989,7 @@ int mfs_pitr_appendnew(FAR struct mfs_sb_s * const sb,
 
   DEBUGASSERT(depth > 0);
 
-  d = kmm_zalloc(sizeof(struct mfs_dirent_s) + len);
+  d = fs_heap_zalloc(sizeof(struct mfs_dirent_s) + len);
   if (predict_false(d == NULL))
     {
       ret = -ENOMEM;
@@ -1043,7 +1044,7 @@ int mfs_pitr_traversefs(FAR struct mfs_sb_s * sb, const struct mfs_ctz_s ctz,
   FAR struct mfs_path_s *path     = NULL;
 
   capacity = MFS_TRAVERSE_INITSZ;
-  path = kmm_zalloc(capacity * sizeof(struct mfs_path_s));
+  path = fs_heap_zalloc(capacity * sizeof(struct mfs_path_s));
   if (predict_false(path == NULL))
     {
       ret = -ENOMEM;

fs/mnemofs/mnemofs_journal.c

@@ -82,6 +82,7 @@
 #include <sys/param.h>
 
 #include "mnemofs.h"
+#include "fs_heap.h"
 
 /****************************************************************************
  * Pre-processor Definitions
@@ -185,7 +186,7 @@ int mfs_jrnl_rdlog(FAR const struct mfs_sb_s *const sb,
       goto errout;
     }
 
-  buf = kmm_zalloc(log_sz);
+  buf = fs_heap_zalloc(log_sz);
   if (predict_false(buf == NULL))
     {
       ret = -ENOMEM;
@@ -215,7 +216,7 @@ int mfs_jrnl_rdlog(FAR const struct mfs_sb_s *const sb,
     }
 
 errout_with_buf:
-  kmm_free(buf);
+  fs_heap_free(buf);
 
 errout:
   return ret;
@@ -297,7 +298,7 @@ FAR static const char *deser_log(FAR const char * const in,
 
   /* Allocates path. Deallocate using mfs_jrnl_log_free. */
 
-  x->path = kmm_zalloc(sizeof(struct mfs_jrnl_log_s) * x->depth);
+  x->path = fs_heap_zalloc(sizeof(struct mfs_jrnl_log_s) * x->depth);
   if (predict_false(x->path == NULL))
     {
       return NULL;
@@ -328,7 +329,7 @@ FAR static const char *deser_log(FAR const char * const in,
 
 void mfs_jrnl_log_free(FAR const struct mfs_jrnl_log_s * const log)
 {
-  free(log->path);
+  fs_heap_free(log->path);
 }
 
 /****************************************************************************
@@ -430,7 +431,7 @@ int mfs_jrnl_fmt(FAR struct mfs_sb_s * const sb, FAR mfs_t *blk1,
 
   sz = MFS_JRNL_SUFFIXSZ + ((CONFIG_MNEMOFS_JOURNAL_NBLKS + 2) * 4);
 
-  buf = kmm_zalloc(sz);
+  buf = fs_heap_zalloc(sz);
   if (predict_false(buf == NULL))
     {
       ret = -ENOMEM;
@@ -508,7 +509,7 @@ int mfs_jrnl_fmt(FAR struct mfs_sb_s * const sb, FAR mfs_t *blk1,
   MFS_JRNL(sb).mblk2         = *blk2;
 
 errout_with_buf:
-  kmm_free(buf);
+  fs_heap_free(buf);
 
 errout:
   return ret;
@@ -631,7 +632,7 @@ int mfs_jrnl_wrlog(FAR struct mfs_sb_s * const sb,
   const mfs_t            log_sz   = sizeof(mfs_t) + MFS_LOGSZ(node->depth);
   struct mfs_jrnl_log_s  log;
 
-  buf = kmm_zalloc(log_sz); /* For size before log. */
+  buf = fs_heap_zalloc(log_sz); /* For size before log. */
   if (predict_false(buf == NULL))
     {
       ret = -ENOMEM;
@@ -677,7 +678,7 @@ int mfs_jrnl_wrlog(FAR struct mfs_sb_s * const sb,
   MFS_JRNL(sb).n_logs++;
 
 errout_with_buf:
-  kmm_free(buf);
+  fs_heap_free(buf);
 
 errout:
   return ret;
@@ -753,7 +754,7 @@ int mfs_jrnl_flush(FAR struct mfs_sb_s * const sb)
       tmp_blkidx    = blkidx;
       tmp_pg_in_blk = pg_in_blk;
 
-      path = kmm_zalloc(log.depth * sizeof(struct mfs_path_s));
+      path = fs_heap_zalloc(log.depth * sizeof(struct mfs_path_s));
       if (predict_false(path == NULL))
         {
           goto errout;

fs/mnemofs/mnemofs_lru.c

@@ -74,6 +74,7 @@
 #include <sys/param.h>
 
 #include "mnemofs.h"
+#include "fs_heap.h"
 
 /****************************************************************************
  * Pre-processor Definitions
@@ -265,8 +266,8 @@ static bool lru_isnodefull(FAR struct mfs_sb_s * const sb,
 
 static void lru_free_delta(FAR struct mfs_delta_s *delta)
 {
-  kmm_free(delta->upd);
+  fs_heap_free(delta->upd);
-  kmm_free(delta);
+  fs_heap_free(delta);
 }
 
 /****************************************************************************
@@ -391,7 +392,7 @@ static int lru_wrtooff(FAR struct mfs_sb_s * const sb, const mfs_t data_off,
 
   if (node == NULL)
     {
-      node = kmm_zalloc(sizeof(*node));
+      node = fs_heap_zalloc(sizeof(*node));
       if (predict_false(node == NULL))
         {
           found = false;
@@ -399,7 +400,7 @@ static int lru_wrtooff(FAR struct mfs_sb_s * const sb, const mfs_t data_off,
           goto errout;
         }
 
-      node->path = kmm_zalloc(depth * sizeof(struct mfs_path_s));
+      node->path = fs_heap_zalloc(depth * sizeof(struct mfs_path_s));
       if (predict_false(node->path == NULL))
         {
           found = false;
@@ -455,7 +456,7 @@ static int lru_wrtooff(FAR struct mfs_sb_s * const sb, const mfs_t data_off,
   /* Add delta to node. */
 
   finfo("Adding delta to the node.");
-  delta = kmm_zalloc(sizeof(*delta));
+  delta = fs_heap_zalloc(sizeof(*delta));
   if (predict_false(delta == NULL))
     {
       ret = -ENOMEM;
@@ -466,7 +467,7 @@ static int lru_wrtooff(FAR struct mfs_sb_s * const sb, const mfs_t data_off,
 
   if (op == MFS_LRU_UPD)
     {
-      delta->upd = kmm_zalloc(bytes);
+      delta->upd = fs_heap_zalloc(bytes);
       if (predict_false(delta->upd == NULL))
         {
           ret = -ENOMEM;
@@ -511,13 +512,13 @@ static int lru_wrtooff(FAR struct mfs_sb_s * const sb, const mfs_t data_off,
 
 errout_with_delta:
   list_delete(&delta->list);
-  kmm_free(delta);
+  fs_heap_free(delta);
 
 errout_with_node:
   if (!found && node != NULL)
     {
       list_delete(&node->list);
-      kmm_free(node);
+      fs_heap_free(node);
     }
 
 errout:
@@ -622,7 +623,7 @@ errout:
 static void lru_node_free(FAR struct mfs_node_s *node)
 {
   mfs_free_patharr(node->path);
-  kmm_free(node);
+  fs_heap_free(node);
 }
 
 static bool lru_sort_cmp(FAR struct mfs_node_s * const node,
@@ -761,7 +762,7 @@ int mfs_lru_flush(FAR struct mfs_sb_s * const sb)
             {
               finfo("Adding parent to LRU");
 
-              tmp = kmm_zalloc(sizeof(struct mfs_node_s));
+              tmp = fs_heap_zalloc(sizeof(struct mfs_node_s));
               if (predict_false(tmp == NULL))
                 {
                   ret = -ENOMEM;
@@ -774,7 +775,7 @@ int mfs_lru_flush(FAR struct mfs_sb_s * const sb)
               /* TODO: Time fields. in tmp. */
 
               tmp->depth = node->depth - 1;
-              tmp->path  = kmm_zalloc((node->depth - 1)
+              tmp->path  = fs_heap_zalloc((node->depth - 1)
                                       * sizeof(struct mfs_path_s));
               if (predict_false(tmp->path == NULL))
                 {

fs/mount/fs_automount.c

@@ -49,6 +49,7 @@
 #endif /* CONFIG_FS_AUTOMOUNTER_DRIVER */
 
 #include "inode/inode.h"
+#include "fs_heap.h"
 
 /****************************************************************************
  * Pre-processor Definitions
@@ -213,7 +214,7 @@ static int automount_open(FAR struct file *filep)
 
   /* Allocate a new open structure */
 
-  opriv = kmm_zalloc(sizeof(struct automounter_open_s));
+  opriv = fs_heap_zalloc(sizeof(struct automounter_open_s));
   if (opriv == NULL)
     {
       ferr("ERROR: Failed to allocate open structure\n");
@@ -295,7 +296,7 @@ static int automount_close(FAR struct file *filep)
 
   /* And free the open structure */
 
-  kmm_free(opriv);
+  fs_heap_free(opriv);
 
   ret = OK;
 
@@ -818,7 +819,7 @@ FAR void *automount_initialize(FAR const struct automount_lower_s *lower)
 
   /* Allocate an auto-mounter state structure */
 
-  priv = kmm_zalloc(sizeof(struct automounter_state_s));
+  priv = fs_heap_zalloc(sizeof(struct automounter_state_s));
   if (priv == NULL)
     {
       ferr("ERROR: Failed to allocate state structure\n");
@@ -931,5 +932,5 @@ void automount_uninitialize(FAR void *handle)
 
   /* And free the state structure */
 
-  kmm_free(priv);
+  fs_heap_free(priv);
 }

fs/mount/fs_procfs_mount.c

@@ -46,6 +46,7 @@
 #include <nuttx/fs/procfs.h>
 
 #include "mount/mount.h"
+#include "fs_heap.h"
 
 #if !defined(CONFIG_DISABLE_MOUNTPOINT) && defined(CONFIG_FS_PROCFS)
 #if !defined(CONFIG_FS_PROCFS_EXCLUDE_MOUNT) || \
@@ -409,7 +410,7 @@ static int mount_open(FAR struct file *filep, FAR const char *relpath,
   /* Allocate a container to hold the task and node selection */
 
   procfile = (FAR struct mount_file_s *)
-    kmm_zalloc(sizeof(struct mount_file_s));
+    fs_heap_zalloc(sizeof(struct mount_file_s));
   if (!procfile)
     {
       ferr("ERROR: Failed to allocate file container\n");
@@ -441,7 +442,7 @@ static int mount_close(FAR struct file *filep)
 
   /* Release the file container structure */
 
-  kmm_free(procfile);
+  fs_heap_free(procfile);
   filep->f_priv = NULL;
   return OK;
 }
@@ -539,7 +540,7 @@ static int mount_dup(FAR const struct file *oldp, FAR struct file *newp)
   /* Allocate a new container to hold the task and node selection */
 
   newfile = (FAR struct mount_file_s *)
-    kmm_malloc(sizeof(struct mount_file_s));
+    fs_heap_malloc(sizeof(struct mount_file_s));
   if (!newfile)
     {
       ferr("ERROR: Failed to allocate file container\n");

fs/nfs/nfs_vfsops.c

@@ -73,6 +73,8 @@
 #include <netinet/in.h>
 #include <arpa/inet.h>
 
+#include "fs_heap.h"
+
 #include "nfs.h"
 #include "rpc.h"
 #include "nfs_proto.h"
@@ -663,7 +665,7 @@ static int nfs_open(FAR struct file *filep, FAR const char *relpath,
 
   /* Pre-allocate the file private data to describe the opened file. */
 
-  np = kmm_zalloc(sizeof(struct nfsnode));
+  np = fs_heap_zalloc(sizeof(struct nfsnode));
   if (!np)
     {
       ferr("ERROR: Failed to allocate private data\n");
@@ -673,7 +675,7 @@ static int nfs_open(FAR struct file *filep, FAR const char *relpath,
   ret = nxmutex_lock(&nmp->nm_lock);
   if (ret < 0)
     {
-      kmm_free(np);
+      fs_heap_free(np);
       return ret;
     }
 
@@ -744,7 +746,7 @@ static int nfs_open(FAR struct file *filep, FAR const char *relpath,
 errout_with_lock:
   if (np)
     {
-      kmm_free(np);
+      fs_heap_free(np);
     }
 
   nxmutex_unlock(&nmp->nm_lock);
@@ -837,7 +839,7 @@ static int nfs_close(FAR struct file *filep)
 
               /* Then deallocate the file structure and return success */
 
-              kmm_free(np);
+              fs_heap_free(np);
               ret = OK;
               break;
             }
@@ -1497,7 +1499,7 @@ static int nfs_opendir(FAR struct inode *mountpt, FAR const char *relpath,
   /* Recover our private data from the inode instance */
 
   nmp = mountpt->i_private;
-  ndir = kmm_zalloc(sizeof(*ndir));
+  ndir = fs_heap_zalloc(sizeof(*ndir));
   if (ndir == NULL)
     {
       return -ENOMEM;
@@ -1543,7 +1545,7 @@ static int nfs_opendir(FAR struct inode *mountpt, FAR const char *relpath,
 errout_with_lock:
   nxmutex_unlock(&nmp->nm_lock);
 errout_with_ndir:
-  kmm_free(ndir);
+  fs_heap_free(ndir);
   return ret;
 }
 
@@ -1562,7 +1564,7 @@ static int nfs_closedir(FAR struct inode *mountpt,
                         FAR struct fs_dirent_s *dir)
 {
   DEBUGASSERT(dir);
-  kmm_free(dir);
+  fs_heap_free(dir);
   return 0;
 }
 
@@ -2077,7 +2079,7 @@ static int nfs_bind(FAR struct inode *blkdriver, FAR const void *data,
 
   /* Create an instance of the mountpt state structure */
 
-  nmp = kmm_zalloc(SIZEOF_nfsmount(buflen));
+  nmp = fs_heap_zalloc(SIZEOF_nfsmount(buflen));
   if (!nmp)
     {
       ferr("ERROR: Failed to allocate mountpoint structure\n");
@@ -2117,7 +2119,7 @@ static int nfs_bind(FAR struct inode *blkdriver, FAR const void *data,
 
   /* Create an instance of the rpc state structure */
 
-  rpc = kmm_zalloc(sizeof(struct rpcclnt));
+  rpc = fs_heap_zalloc(sizeof(struct rpcclnt));
   if (!rpc)
     {
       ferr("ERROR: Failed to allocate rpc structure\n");
@@ -2169,13 +2171,13 @@ bad:
   if (nmp->nm_rpcclnt)
     {
       rpcclnt_disconnect(nmp->nm_rpcclnt);
-      kmm_free(nmp->nm_rpcclnt);
+      fs_heap_free(nmp->nm_rpcclnt);
     }
 
   /* Free connection-related resources */
 
   nxmutex_destroy(&nmp->nm_lock);
-  kmm_free(nmp);
+  fs_heap_free(nmp);
 
   return ret;
 }
@@ -2233,8 +2235,8 @@ static int nfs_unbind(FAR void *handle, FAR struct inode **blkdriver,
   /* And free any allocated resources */
 
   nxmutex_destroy(&nmp->nm_lock);
-  kmm_free(nmp->nm_rpcclnt);
+  fs_heap_free(nmp->nm_rpcclnt);
-  kmm_free(nmp);
+  fs_heap_free(nmp);
 
   return OK;
 

fs/notify/inotify.c

@@ -41,6 +41,7 @@
 
 #include "inode/inode.h"
 #include "sched/sched.h"
+#include "fs_heap.h"
 
 /****************************************************************************
  * Pre-processor Definitions
@@ -210,7 +211,7 @@ inotify_alloc_event(int wd, uint32_t mask, uint32_t cookie,
       len = ROUND_UP(strlen(name) + 1, sizeof(struct inotify_event));
     }
 
-  event = kmm_malloc(sizeof(struct inotify_event_s) + len);
+  event = fs_heap_malloc(sizeof(struct inotify_event_s) + len);
   if (event == NULL)
     {
       return NULL;
@@ -308,7 +309,7 @@ inotify_remove_watch_no_event(FAR struct inotify_watch_s *watch)
   list_delete(&watch->d_node);
   list_delete(&watch->l_node);
   inotify_sub_count(watch->mask);
-  kmm_free(watch);
+  fs_heap_free(watch);
 
   if (list_is_empty(&list->watches))
     {
@@ -347,7 +348,7 @@ static void inotify_remove_event(FAR struct inotify_device_s *dev,
   list_delete(&event->node);
   dev->event_size -= sizeof(struct inotify_event) + event->event.len;
   dev->event_count--;
-  kmm_free(event);
+  fs_heap_free(event);
 }
 
 /****************************************************************************
@@ -362,7 +363,7 @@ static FAR struct inotify_device_s *inotify_alloc_device(void)
 {
   FAR struct inotify_device_s *dev;
 
-  dev = kmm_zalloc(sizeof(struct inotify_device_s));
+  dev = fs_heap_zalloc(sizeof(struct inotify_device_s));
   if (dev == NULL)
     {
       return dev;
@@ -584,7 +585,7 @@ static int inotify_close(FAR struct file *filep)
   nxmutex_unlock(&g_inotify.lock);
   nxmutex_destroy(&dev->lock);
   nxsem_destroy(&dev->sem);
-  kmm_free(dev);
+  fs_heap_free(dev);
   return OK;
 }
 
@@ -653,7 +654,7 @@ inotify_alloc_watch(FAR struct inotify_device_s *dev,
 {
   FAR struct inotify_watch_s *watch;
 
-  watch = kmm_zalloc(sizeof(struct inotify_watch_s));
+  watch = fs_heap_zalloc(sizeof(struct inotify_watch_s));
   if (watch == NULL)
     {
       return NULL;
@@ -738,7 +739,7 @@ inotify_alloc_watch_list(FAR const char *path)
   FAR ENTRY *result;
   ENTRY item;
 
-  list = kmm_zalloc(sizeof(struct inotify_watch_list_s));
+  list = fs_heap_zalloc(sizeof(struct inotify_watch_list_s));
   if (list == NULL)
     {
       return NULL;
@@ -748,7 +749,7 @@ inotify_alloc_watch_list(FAR const char *path)
   list->path = strdup(path);
   if (list->path == NULL)
     {
-      kmm_free(list);
+      fs_heap_free(list);
       return NULL;
     }
 
@@ -757,7 +758,7 @@ inotify_alloc_watch_list(FAR const char *path)
   if (hsearch_r(item, ENTER, &result, &g_inotify.hash) == 0)
     {
       lib_free(list->path);
-      kmm_free(list);
+      fs_heap_free(list);
       return NULL;
     }
 
@@ -1019,10 +1020,10 @@ static inline void notify_queue_filep_event(FAR struct file *filep,
 
 static void notify_free_entry(FAR ENTRY *entry)
 {
-  /* Key is alloced by lib_malloc, value is alloced by kmm_malloc */
+  /* Key is alloced by lib_malloc, value is alloced by fs_heap_malloc */
 
   lib_free(entry->key);
-  kmm_free(entry->data);
+  fs_heap_free(entry->data);
 }
 
 /****************************************************************************
@@ -1262,7 +1263,7 @@ int inotify_init1(int flags)
 exit_with_dev:
   nxmutex_destroy(&dev->lock);
   nxsem_destroy(&dev->sem);
-  kmm_free(dev);
+  fs_heap_free(dev);
 exit_set_errno:
   set_errno(-ret);
   return ERROR;

fs/nxffs/nxffs.h

@@ -555,8 +555,8 @@ int nxffs_getc(FAR struct nxffs_volume_s *volume, uint16_t reserve);
  *   to dispose of that memory when the inode entry is no longer needed.
  *
  *   Note that the nxffs_entry_s containing structure is not freed.  The
- *   caller may call kmm_free upon return of this function if necessary to
+ *   caller may call fs_heap_free upon return of this function if necessary
- *   free the entry container.
+ *   to free the entry container.
  *
  * Input Parameters:
  *   entry  - The entry to be freed.

fs/nxffs/nxffs_dirent.c

@@ -35,6 +35,7 @@
 #include <nuttx/kmalloc.h>
 
 #include "nxffs.h"
+#include "fs_heap.h"
 
 /****************************************************************************
  * Private Types
@@ -74,7 +75,7 @@ int nxffs_opendir(FAR struct inode *mountpt, FAR const char *relpath,
   /* Recover the file system state from the NuttX inode instance */
 
   volume = mountpt->i_private;
-  ndir = kmm_zalloc(sizeof(*ndir));
+  ndir = fs_heap_zalloc(sizeof(*ndir));
   if (ndir == NULL)
     {
       return -ENOMEM;
@@ -105,7 +106,7 @@ errout_with_lock:
   nxmutex_unlock(&volume->lock);
 
 errout_with_ndir:
-  kmm_free(ndir);
+  fs_heap_free(ndir);
   return ret;
 }
 
@@ -121,7 +122,7 @@ int nxffs_closedir(FAR struct inode *mountpt,
                    FAR struct fs_dirent_s *dir)
 {
   DEBUGASSERT(dir);
-  kmm_free(dir);
+  fs_heap_free(dir);
   return 0;
 }
 

fs/nxffs/nxffs_dump.c

@@ -34,6 +34,7 @@
 #include <nuttx/mtd/mtd.h>
 
 #include "nxffs.h"
+#include "fs_heap.h"
 
 /****************************************************************************
  * Pre-processor Definitions
@@ -443,7 +444,7 @@ int nxffs_dump(FAR struct mtd_dev_s *mtd, bool verbose)
 
   /* Allocate a buffer to hold one block */
 
-  blkinfo.buffer = kmm_malloc(blkinfo.geo.blocksize);
+  blkinfo.buffer = fs_heap_malloc(blkinfo.geo.blocksize);
   if (!blkinfo.buffer)
     {
       ferr("ERROR: Failed to allocate block cache\n");
@@ -470,7 +471,7 @@ int nxffs_dump(FAR struct mtd_dev_s *mtd, bool verbose)
           /* Read errors are fatal */
 
           ferr("ERROR: Failed to read block %d\n", blkinfo.block);
-          kmm_free(blkinfo.buffer);
+          fs_heap_free(blkinfo.buffer);
           return ret;
 #else
           /* A read error is probably fatal on all media but NAND.
@@ -493,7 +494,7 @@ int nxffs_dump(FAR struct mtd_dev_s *mtd, bool verbose)
 
   syslog(LOG_NOTICE, "%" PRIi32 " blocks analyzed\n", blkinfo.nblocks);
 
-  kmm_free(blkinfo.buffer);
+  fs_heap_free(blkinfo.buffer);
   return OK;
 
 #else

fs/nxffs/nxffs_initialize.c

@@ -36,6 +36,7 @@
 #include <nuttx/fs/ioctl.h>
 
 #include "nxffs.h"
+#include "fs_heap.h"
 
 /****************************************************************************
  * Private Data
@@ -162,7 +163,7 @@ int nxffs_initialize(FAR struct mtd_dev_s *mtd)
 
   /* Allocate a NXFFS volume structure */
 
-  volume = kmm_zalloc(sizeof(struct nxffs_volume_s));
+  volume = fs_heap_zalloc(sizeof(struct nxffs_volume_s));
   if (!volume)
     {
       return -ENOMEM;
@@ -191,7 +192,7 @@ int nxffs_initialize(FAR struct mtd_dev_s *mtd)
 
   /* Allocate one I/O block buffer to general files system access */
 
-  volume->cache = kmm_malloc(volume->geo.blocksize);
+  volume->cache = fs_heap_malloc(volume->geo.blocksize);
   if (!volume->cache)
     {
       ferr("ERROR: Failed to allocate an erase block buffer\n");
@@ -204,7 +205,7 @@ int nxffs_initialize(FAR struct mtd_dev_s *mtd)
    * is not needed often, but is best to have pre-allocated and in-place.
    */
 
-  volume->pack = kmm_malloc(volume->geo.erasesize);
+  volume->pack = fs_heap_malloc(volume->geo.erasesize);
   if (!volume->pack)
     {
       ferr("ERROR: Failed to allocate an I/O block buffer\n");
@@ -302,14 +303,14 @@ int nxffs_initialize(FAR struct mtd_dev_s *mtd)
   ferr("ERROR: Failed to calculate file system limits: %d\n", -ret);
 
 errout_with_buffer:
-  kmm_free(volume->pack);
+  fs_heap_free(volume->pack);
 errout_with_cache:
-  kmm_free(volume->cache);
+  fs_heap_free(volume->cache);
 errout_with_volume:
   nxmutex_destroy(&volume->lock);
   nxsem_destroy(&volume->wrsem);
 #ifndef CONFIG_NXFFS_PREALLOCATED
-  kmm_free(volume);
+  fs_heap_free(volume);
 #endif
   return ret;
 }

fs/nxffs/nxffs_inode.c

@@ -35,6 +35,7 @@
 #include <nuttx/mtd/mtd.h>
 
 #include "nxffs.h"
+#include "fs_heap.h"
 
 /****************************************************************************
  * Private Functions
@@ -108,7 +109,7 @@ static int nxffs_rdentry(FAR struct nxffs_volume_s *volume, off_t offset,
   /* Allocate memory to hold the variable-length file name */
 
   namlen = inode.namlen;
-  entry->name = kmm_malloc(namlen + 1);
+  entry->name = fs_heap_malloc(namlen + 1);
   if (!entry->name)
     {
       ferr("ERROR: Failed to allocate name, namlen: %d\n", namlen);
@@ -197,8 +198,8 @@ errout:
  *   to dispose of that memory when the inode entry is no longer needed.
  *
  *   Note that the nxffs_entry_s containing structure is not freed.  The
- *   caller may call kmm_free upon return of this function if necessary to
+ *   caller may call fs_heap_free upon return of this function if necessary
- *   free the entry container.
+ *   to free the entry container.
  *
  * Input Parameters:
  *   entry  - The entry to be freed.

fs/nxffs/nxffs_open.c

@@ -38,6 +38,7 @@
 #include <nuttx/mtd/mtd.h>
 
 #include "nxffs.h"
+#include "fs_heap.h"
 
 /****************************************************************************
  * Private Data
@@ -490,7 +491,7 @@ static inline int nxffs_wropen(FAR struct nxffs_volume_s *volume,
   memset(wrfile, 0, sizeof(struct nxffs_wrfile_s));
 #else
   wrfile = (FAR struct nxffs_wrfile_s *)
-           kmm_zalloc(sizeof(struct nxffs_wrfile_s));
+           fs_heap_zalloc(sizeof(struct nxffs_wrfile_s));
   if (!wrfile)
     {
       ret = -ENOMEM;
@@ -657,7 +658,7 @@ errout_with_name:
   lib_free(wrfile->ofile.entry.name);
 errout_with_ofile:
 #ifndef CONFIG_NXFFS_PREALLOCATED
-  kmm_free(wrfile);
+  fs_heap_free(wrfile);
 #endif
 
 errout_with_lock:
@@ -726,7 +727,7 @@ static inline int nxffs_rdopen(FAR struct nxffs_volume_s *volume,
       /* Not already open.. create a new open structure */
 
       ofile = (FAR struct nxffs_ofile_s *)
-              kmm_zalloc(sizeof(struct nxffs_ofile_s));
+              fs_heap_zalloc(sizeof(struct nxffs_ofile_s));
       if (!ofile)
         {
           ferr("ERROR: ofile allocation failed\n");
@@ -761,7 +762,7 @@ static inline int nxffs_rdopen(FAR struct nxffs_volume_s *volume,
   return OK;
 
 errout_with_ofile:
-  kmm_free(ofile);
+  fs_heap_free(ofile);
 errout_with_lock:
   nxmutex_unlock(&volume->lock);
 errout:
@@ -832,7 +833,7 @@ static inline void nxffs_freeofile(FAR struct nxffs_volume_s *volume,
   if ((FAR struct nxffs_wrfile_s *)ofile != &g_wrfile)
 #endif
     {
-      kmm_free(ofile);
+      fs_heap_free(ofile);
     }
 }
 

fs/partition/fs_gpt.c

@@ -32,6 +32,7 @@
 #include <nuttx/kmalloc.h>
 
 #include "partition.h"
+#include "fs_heap.h"
 
 /****************************************************************************
  * Pre-processor Definitions
@@ -205,7 +206,7 @@ gpt_alloc_verify_entries(FAR struct partition_state_s *state,
     }
 
   blk = (size + (state->blocksize - 1)) / state->blocksize;
-  pte = kmm_zalloc(blk * state->blocksize);
+  pte = fs_heap_zalloc(blk * state->blocksize);
   if (!pte)
     {
       return NULL;
@@ -216,7 +217,7 @@ gpt_alloc_verify_entries(FAR struct partition_state_s *state,
   ret = read_partition_block(state, pte, from, blk);
   if (ret < 0)
     {
-      kmm_free(pte);
+      fs_heap_free(pte);
       ferr("Read ptr from block failed:%d.\n", ret);
       return NULL;
     }
@@ -227,7 +228,7 @@ gpt_alloc_verify_entries(FAR struct partition_state_s *state,
   if (crc != le32toh(gpt->partition_entry_array_crc32))
     {
       ferr("GUID Partitition Entry Array CRC check failed.\n");
-      kmm_free(pte);
+      fs_heap_free(pte);
       return NULL;
     }
 
@@ -399,7 +400,7 @@ int parse_gpt_partition(FAR struct partition_state_s *state,
 
   count = (sizeof(struct gpt_ptable_s) + (state->blocksize - 1)) /
           state->blocksize;
-  ptbl = kmm_malloc(count * state->blocksize);
+  ptbl = fs_heap_malloc(count * state->blocksize);
   if (!ptbl)
     {
       return -ENOMEM;
@@ -485,8 +486,8 @@ int parse_gpt_partition(FAR struct partition_state_s *state,
       handler(&pentry, arg);
     }
 
-  kmm_free(ptes);
+  fs_heap_free(ptes);
 err:
-  kmm_free(ptbl);
+  fs_heap_free(ptbl);
   return ret;
 }

fs/partition/fs_mbr.c

@@ -30,6 +30,7 @@
 #include <nuttx/kmalloc.h>
 
 #include "partition.h"
+#include "fs_heap.h"
 
 /****************************************************************************
  * Pre-processor Definitions
@@ -109,7 +110,7 @@ int parse_mbr_partition(FAR struct partition_state_s *state,
   int i;
 
   num = (MBR_SIZE + state->blocksize - 1) / state->blocksize;
-  buffer = kmm_malloc(num * state->blocksize);
+  buffer = fs_heap_malloc(num * state->blocksize);
   if (!buffer)
     {
       return -ENOMEM;
@@ -118,13 +119,13 @@ int parse_mbr_partition(FAR struct partition_state_s *state,
   ret = read_partition_block(state, buffer, 0, num);
   if (ret < 0)
     {
-      kmm_free(buffer);
+      fs_heap_free(buffer);
       return ret;
     }
 
   if (buffer[0x1fe] != 0x55 || buffer[0x1ff] != 0xaa)
     {
-      kmm_free(buffer);
+      fs_heap_free(buffer);
       return -EINVAL;
     }
 
@@ -211,6 +212,6 @@ int parse_mbr_partition(FAR struct partition_state_s *state,
     }
 
 out:
-  kmm_free(buffer);
+  fs_heap_free(buffer);
   return ret;
 }

fs/partition/fs_ptable.c

@@ -27,6 +27,7 @@
 #include <nuttx/kmalloc.h>
 
 #include "partition.h"
+#include "fs_heap.h"
 
 /****************************************************************************
  * Pre-processor Definitions
@@ -91,7 +92,7 @@ int parse_ptable_partition(FAR struct partition_state_s *state,
 
   /* Allocate one erase block memory */
 
-  ptable = kmm_malloc(state->erasesize);
+  ptable = fs_heap_malloc(state->erasesize);
   if (ptable == NULL)
     {
       return -ENOMEM;
@@ -149,6 +150,6 @@ int parse_ptable_partition(FAR struct partition_state_s *state,
     }
 
 out:
-  kmm_free(ptable);
+  fs_heap_free(ptable);
   return ret;
 }

fs/partition/fs_txtable.c

@@ -30,6 +30,7 @@
 #include <nuttx/kmalloc.h>
 
 #include "partition.h"
+#include "fs_heap.h"
 
 /****************************************************************************
  * Pre-processor Definitions
@@ -77,7 +78,7 @@ int parse_txtable_partition(FAR struct partition_state_s *state,
 
   /* Allocate memory for table of parsed and raw */
 
-  part = kmm_malloc(CONFIG_TXTABLE_PARTITION_MAX_NUM *
+  part = fs_heap_malloc(CONFIG_TXTABLE_PARTITION_MAX_NUM *
                     sizeof(struct partition_s) +
                     TXTABLE_LENGTH);
   if (part == NULL)
@@ -217,6 +218,6 @@ int parse_txtable_partition(FAR struct partition_state_s *state,
   handler(&part[j], arg);
 
 out:
-  kmm_free(part);
+  fs_heap_free(part);
   return ret;
 }

fs/procfs/fs_procfs.c

@@ -48,6 +48,7 @@
 
 #include "mount/mount.h"
 #include "sched/sched.h"
+#include "fs_heap.h"
 
 /****************************************************************************
  * External Definitions
@@ -468,7 +469,7 @@ static int procfs_close(FAR struct file *filep)
     }
   else
     {
-      kmm_free(attr);
+      fs_heap_free(attr);
     }
 
   filep->f_priv = NULL;
@@ -656,7 +657,7 @@ static int procfs_opendir(FAR struct inode *mountpt, FAR const char *relpath,
 #endif
 
       level0 = (FAR struct procfs_level0_s *)
-         kmm_zalloc(sizeof(struct procfs_level0_s) + sizeof(pid_t) * num) ;
+      fs_heap_zalloc(sizeof(struct procfs_level0_s) + sizeof(pid_t) * num);
       if (!level0)
         {
           ferr("ERROR: Failed to allocate the level0 directory structure\n");
@@ -742,7 +743,7 @@ static int procfs_opendir(FAR struct inode *mountpt, FAR const char *relpath,
                */
 
               level1 = (FAR struct procfs_level1_s *)
-                 kmm_zalloc(sizeof(struct procfs_level1_s));
+                 fs_heap_zalloc(sizeof(struct procfs_level1_s));
               if (!level1)
                 {
                   ferr("ERROR: Failed to allocate the level0 directory "
@@ -783,7 +784,7 @@ static int procfs_closedir(FAR struct inode *mountpt,
                            FAR struct fs_dirent_s *dir)
 {
   DEBUGASSERT(mountpt && dir);
-  kmm_free(dir);
+  fs_heap_free(dir);
   return OK;
 }
 
@@ -1180,7 +1181,7 @@ int procfs_initialize(void)
       /* No.. allocate a modifiable list of entries */
 
       g_procfs_entries = (FAR struct procfs_entry_s *)
-        kmm_malloc(sizeof(g_base_entries));
+        fs_heap_malloc(sizeof(g_base_entries));
       if (g_procfs_entries == NULL)
         {
           return -ENOMEM;
@@ -1246,7 +1247,7 @@ int procfs_register(FAR const struct procfs_entry_s *entry)
   newsize  = newcount * sizeof(struct procfs_entry_s);
 
   newtable = (FAR struct procfs_entry_s *)
-    kmm_realloc(g_procfs_entries, newsize);
+    fs_heap_realloc(g_procfs_entries, newsize);
   if (newtable != NULL)
     {
       /* Copy the new entry at the end of the reallocated table */

fs/procfs/fs_procfscpuinfo.c

@@ -36,6 +36,8 @@
 #include <nuttx/fs/fs.h>
 #include <nuttx/fs/procfs.h>
 
+#include "fs_heap.h"
+
 #if defined(CONFIG_ARCH_HAVE_CPUINFO) && !defined(CONFIG_FS_PROCFS_EXCLUDE_CPUINFO)
 
 /****************************************************************************
@@ -105,7 +107,7 @@ static int cpuinfo_open(FAR struct file *filep, FAR const char *relpath,
 
   /* Allocate a container to hold the file attributes */
 
-  procfile = kmm_zalloc(sizeof(struct cpuinfo_file_s));
+  procfile = fs_heap_zalloc(sizeof(struct cpuinfo_file_s));
   if (procfile == NULL)
     {
       ferr("ERROR: Failed to allocate file attributes\n");
@@ -133,7 +135,7 @@ static int cpuinfo_close(FAR struct file *filep)
 
   /* Release the file attributes structure */
 
-  kmm_free(procfile);
+  fs_heap_free(procfile);
   filep->f_priv = NULL;
   return OK;
 }
@@ -188,7 +190,7 @@ static int cpuinfo_dup(FAR const struct file *oldp, FAR struct file *newp)
 
   /* Allocate a new container to hold the task and attribute selection */
 
-  newattr = kmm_malloc(sizeof(struct cpuinfo_file_s));
+  newattr = fs_heap_malloc(sizeof(struct cpuinfo_file_s));
   if (newattr == NULL)
     {
       ferr("ERROR: Failed to allocate file attributes\n");

fs/procfs/fs_procfscpuload.c

@@ -44,6 +44,8 @@
 #include <nuttx/fs/fs.h>
 #include <nuttx/fs/procfs.h>
 
+#include "fs_heap.h"
+
 #if !defined(CONFIG_DISABLE_MOUNTPOINT) && defined(CONFIG_FS_PROCFS)
 #if !defined(CONFIG_SCHED_CPULOAD_NONE) && \
     !defined(CONFIG_FS_PROCFS_EXCLUDE_CPULOAD)
@@ -142,7 +144,7 @@ static int cpuload_open(FAR struct file *filep, FAR const char *relpath,
 
   /* Allocate a container to hold the file attributes */
 
-  attr = kmm_zalloc(sizeof(struct cpuload_file_s));
+  attr = fs_heap_zalloc(sizeof(struct cpuload_file_s));
   if (!attr)
     {
       ferr("ERROR: Failed to allocate file attributes\n");
@@ -170,7 +172,7 @@ static int cpuload_close(FAR struct file *filep)
 
   /* Release the file attributes structure */
 
-  kmm_free(attr);
+  fs_heap_free(attr);
   filep->f_priv = NULL;
   return OK;
 }
@@ -300,7 +302,7 @@ static int cpuload_dup(FAR const struct file *oldp, FAR struct file *newp)
 
   /* Allocate a new container to hold the task and attribute selection */
 
-  newattr = kmm_malloc(sizeof(struct cpuload_file_s));
+  newattr = fs_heap_malloc(sizeof(struct cpuload_file_s));
   if (!newattr)
     {
       ferr("ERROR: Failed to allocate file attributes\n");

fs/procfs/fs_procfscritmon.c

@@ -43,6 +43,8 @@
 #include <nuttx/fs/fs.h>
 #include <nuttx/fs/procfs.h>
 
+#include "fs_heap.h"
+
 #if !defined(CONFIG_DISABLE_MOUNTPOINT) && defined(CONFIG_FS_PROCFS) && \
      defined(CONFIG_SCHED_CRITMONITOR)
 
@@ -140,7 +142,7 @@ static int critmon_open(FAR struct file *filep, FAR const char *relpath,
 
   /* Allocate a container to hold the file attributes */
 
-  attr = kmm_zalloc(sizeof(struct critmon_file_s));
+  attr = fs_heap_zalloc(sizeof(struct critmon_file_s));
   if (!attr)
     {
       ferr("ERROR: Failed to allocate file attributes\n");
@@ -168,7 +170,7 @@ static int critmon_close(FAR struct file *filep)
 
   /* Release the file attributes structure */
 
-  kmm_free(attr);
+  fs_heap_free(attr);
   filep->f_priv = NULL;
   return OK;
 }
@@ -348,7 +350,7 @@ static int critmon_dup(FAR const struct file *oldp, FAR struct file *newp)
 
   /* Allocate a new container to hold the task and attribute selection */
 
-  newattr = kmm_malloc(sizeof(struct critmon_file_s));
+  newattr = fs_heap_malloc(sizeof(struct critmon_file_s));
   if (!newattr)
     {
       ferr("ERROR: Failed to allocate file attributes\n");

fs/procfs/fs_procfsfdt.c

@@ -42,6 +42,8 @@
 #include <nuttx/fs/fs.h>
 #include <nuttx/fs/procfs.h>
 
+#include "fs_heap.h"
+
 #if defined(CONFIG_DEVICE_TREE) && !defined(CONFIG_FS_PROCFS_EXCLUDE_FDT)
 
 /****************************************************************************
@@ -123,7 +125,7 @@ static int fdt_open(FAR struct file *filep, FAR const char *relpath,
 
   /* Allocate a container to hold the file attributes */
 
-  attr = kmm_zalloc(sizeof(struct fdt_file_s));
+  attr = fs_heap_zalloc(sizeof(struct fdt_file_s));
   if (attr == NULL)
     {
       ferr("ERROR: Failed to allocate file attributes\n");
@@ -151,7 +153,7 @@ static int fdt_close(FAR struct file *filep)
 
   /* Release the file attributes structure */
 
-  kmm_free(attr);
+  fs_heap_free(attr);
   filep->f_priv = NULL;
   return OK;
 }
@@ -219,7 +221,7 @@ static int fdt_dup(FAR const struct file *oldp, FAR struct file *newp)
 
   /* Allocate a new container to hold the task and attribute selection */
 
-  newattr = kmm_malloc(sizeof(struct fdt_file_s));
+  newattr = fs_heap_malloc(sizeof(struct fdt_file_s));
   if (newattr == NULL)
     {
       ferr("ERROR: Failed to allocate file attributes\n");

fs/procfs/fs_procfsiobinfo.c

@@ -42,6 +42,8 @@
 #include <nuttx/fs/fs.h>
 #include <nuttx/fs/procfs.h>
 
+#include "fs_heap.h"
+
 #if !defined(CONFIG_DISABLE_MOUNTPOINT) && defined(CONFIG_FS_PROCFS) && \
     defined(CONFIG_MM_IOB) && !defined(CONFIG_FS_PROCFS_EXCLUDE_IOBINFO)
 
@@ -137,7 +139,7 @@ static int iobinfo_open(FAR struct file *filep, FAR const char *relpath,
   /* Allocate a container to hold the file attributes */
 
   procfile = (FAR struct iobinfo_file_s *)
-    kmm_zalloc(sizeof(struct iobinfo_file_s));
+    fs_heap_zalloc(sizeof(struct iobinfo_file_s));
   if (!procfile)
     {
       ferr("ERROR: Failed to allocate file attributes\n");
@@ -165,7 +167,7 @@ static int iobinfo_close(FAR struct file *filep)
 
   /* Release the file attributes structure */
 
-  kmm_free(procfile);
+  fs_heap_free(procfile);
   filep->f_priv = NULL;
   return OK;
 }
@@ -248,7 +250,7 @@ static int iobinfo_dup(FAR const struct file *oldp, FAR struct file *newp)
   /* Allocate a new container to hold the task and attribute selection */
 
   newattr = (FAR struct iobinfo_file_s *)
-    kmm_malloc(sizeof(struct iobinfo_file_s));
+    fs_heap_malloc(sizeof(struct iobinfo_file_s));
   if (!newattr)
     {
       ferr("ERROR: Failed to allocate file attributes\n");

fs/procfs/fs_procfsmeminfo.c

@@ -46,6 +46,8 @@
 #include <nuttx/fs/fs.h>
 #include <nuttx/fs/procfs.h>
 
+#include "fs_heap.h"
+
 #ifndef CONFIG_FS_PROCFS_EXCLUDE_MEMINFO
 
 /****************************************************************************
@@ -234,7 +236,7 @@ static int meminfo_open(FAR struct file *filep, FAR const char *relpath,
 
   /* Allocate a container to hold the file attributes */
 
-  procfile = kmm_zalloc(sizeof(struct meminfo_file_s));
+  procfile = fs_heap_zalloc(sizeof(struct meminfo_file_s));
   if (!procfile)
     {
       ferr("ERROR: Failed to allocate file attributes\n");
@@ -262,7 +264,7 @@ static int meminfo_close(FAR struct file *filep)
 
   /* Release the file attributes structure */
 
-  kmm_free(procfile);
+  fs_heap_free(procfile);
   filep->f_priv = NULL;
   return OK;
 }
@@ -617,7 +619,7 @@ static int meminfo_dup(FAR const struct file *oldp, FAR struct file *newp)
   /* Allocate a new container to hold the task and attribute selection */
 
   newattr = (FAR struct meminfo_file_s *)
-    kmm_malloc(sizeof(struct meminfo_file_s));
+    fs_heap_malloc(sizeof(struct meminfo_file_s));
   if (!newattr)
     {
       ferr("ERROR: Failed to allocate file attributes\n");

fs/procfs/fs_procfspressure.c

@@ -36,6 +36,8 @@
 #include <nuttx/queue.h>
 #include <nuttx/spinlock.h>
 
+#include "fs_heap.h"
+
 /****************************************************************************
  * Private Types
  ****************************************************************************/
@@ -121,7 +123,7 @@ static int pressure_open(FAR struct file *filep, FAR const char *relpath,
       return -ENOENT;
     }
 
-  priv = kmm_zalloc(sizeof(struct pressure_file_s));
+  priv = fs_heap_zalloc(sizeof(struct pressure_file_s));
   if (!priv)
     {
       return -ENOMEM;
@@ -147,7 +149,7 @@ static int pressure_close(FAR struct file *filep)
   flags = spin_lock_irqsave(&g_pressure_lock);
   dq_rem(&priv->entry, &g_pressure_memory_queue);
   spin_unlock_irqrestore(&g_pressure_lock, flags);
-  free(priv);
+  fs_heap_free(priv);
   return OK;
 }
 
@@ -292,7 +294,7 @@ static int pressure_dup(FAR const struct file *oldp, FAR struct file *newp)
   FAR struct pressure_file_s *newpriv;
   uint32_t flags;
 
-  newpriv = kmm_zalloc(sizeof(struct pressure_file_s));
+  newpriv = fs_heap_zalloc(sizeof(struct pressure_file_s));
   if (newpriv == NULL)
     {
       return -ENOMEM;
@@ -319,7 +321,7 @@ static int pressure_opendir(FAR const char *relpath,
   finfo("relpath: \"%s\"\n", relpath ? relpath : "NULL");
   DEBUGASSERT(relpath);
 
-  level = kmm_zalloc(sizeof(struct procfs_dir_priv_s));
+  level = fs_heap_zalloc(sizeof(struct procfs_dir_priv_s));
   if (level == NULL)
     {
       return -ENOMEM;
@@ -339,7 +341,7 @@ static int pressure_opendir(FAR const char *relpath,
 static int pressure_closedir(FAR struct fs_dirent_s *dir)
 {
   DEBUGASSERT(dir);
-  kmm_free(dir);
+  fs_heap_free(dir);
   return OK;
 }
 

fs/procfs/fs_procfsproc.c

@@ -57,6 +57,8 @@
 #include <nuttx/mm/mm.h>
 #include <nuttx/queue.h>
 
+#include "fs_heap.h"
+
 #if !defined(CONFIG_SCHED_CPULOAD_NONE) || defined(CONFIG_SCHED_CRITMONITOR)
 #  include <nuttx/clock.h>
 #endif
@@ -904,7 +906,7 @@ static ssize_t proc_heap(FAR struct proc_file_s *procfile,
 #ifdef CONFIG_MM_KERNEL_HEAP
   if ((tcb->flags & TCB_FLAG_TTYPE_MASK) == TCB_FLAG_TTYPE_KERNEL)
     {
-      info = kmm_mallinfo_task(&task);
+      info = fs_heap_mallinfo_task(&task);
     }
   else
 #endif
@@ -1530,7 +1532,7 @@ static int proc_open(FAR struct file *filep, FAR const char *relpath,
   /* Allocate a container to hold the task and node selection */
 
   procfile = (FAR struct proc_file_s *)
-    kmm_zalloc(sizeof(struct proc_file_s));
+    fs_heap_zalloc(sizeof(struct proc_file_s));
   if (procfile == NULL)
     {
       ferr("ERROR: Failed to allocate file container\n");
@@ -1563,7 +1565,7 @@ static int proc_close(FAR struct file *filep)
 
   /* Release the file container structure */
 
-  kmm_free(procfile);
+  fs_heap_free(procfile);
   filep->f_priv = NULL;
   return OK;
 }
@@ -1726,7 +1728,7 @@ static int proc_dup(FAR const struct file *oldp, FAR struct file *newp)
 
   /* Allocate a new container to hold the task and node selection */
 
-  newfile = kmm_malloc(sizeof(struct proc_file_s));
+  newfile = fs_heap_malloc(sizeof(struct proc_file_s));
   if (newfile == NULL)
     {
       ferr("ERROR: Failed to allocate file container\n");
@@ -1815,11 +1817,11 @@ static int proc_opendir(FAR const char *relpath,
     }
 
   /* Allocate the directory structure.  Note that the index and procentry
-   * pointer are implicitly nullified by kmm_zalloc().  Only the remaining,
+   * pointer are implicitly nullified by fs_heap_zalloc().
-   * non-zero entries will need be initialized.
+   * Only the remaining, non-zero entries will need be initialized.
    */
 
-  procdir = kmm_zalloc(sizeof(struct proc_dir_s));
+  procdir = fs_heap_zalloc(sizeof(struct proc_dir_s));
   if (procdir == NULL)
     {
       ferr("ERROR: Failed to allocate the directory structure\n");
@@ -1839,7 +1841,7 @@ static int proc_opendir(FAR const char *relpath,
       if (node == NULL)
         {
           ferr("ERROR: Invalid path \"%s\"\n", relpath);
-          kmm_free(procdir);
+          fs_heap_free(procdir);
           return -ENOENT;
         }
 
@@ -1848,7 +1850,7 @@ static int proc_opendir(FAR const char *relpath,
       if (!DIRENT_ISDIRECTORY(node->dtype))
         {
           ferr("ERROR: Path \"%s\" is not a directory\n", relpath);
-          kmm_free(procdir);
+          fs_heap_free(procdir);
           return -ENOTDIR;
         }
 
@@ -1882,7 +1884,7 @@ static int proc_opendir(FAR const char *relpath,
 static int proc_closedir(FAR struct fs_dirent_s *dir)
 {
   DEBUGASSERT(dir != NULL);
-  kmm_free(dir);
+  fs_heap_free(dir);
   return OK;
 }