Merge pull request #32 from nekernel-org/dev

0.0.2e3

6 files changed, 167 insertions, 187 deletions

diff --git a/dev/kernel/src/FS/Ext2+FileMgr.cc b/dev/kernel/src/FS/Ext2+FileMgr.cc
index a55d917a..810e7e44 100644
--- a/dev/kernel/src/FS/Ext2+FileMgr.cc
+++ b/dev/kernel/src/FS/Ext2+FileMgr.cc
@@ -8,7 +8,7 @@
 #ifdef __FSKIT_INCLUDES_EXT2__
 
 #include <KernelKit/FileMgr.h>
-#include <KernelKit/MemoryMgr.h>
+#include <KernelKit/HeapMgr.h>
 
 #endif  // ifdef __FSKIT_INCLUDES_EXT2__
 #endif  // ifndef __NE_MINIMAL_OS__
diff --git a/dev/kernel/src/FS/Ext2+FileSystemParser.cc b/dev/kernel/src/FS/Ext2+FileSystemParser.cc
index b6d04f46..80449ed9 100644
--- a/dev/kernel/src/FS/Ext2+FileSystemParser.cc
+++ b/dev/kernel/src/FS/Ext2+FileSystemParser.cc
@@ -10,11 +10,11 @@
 #include <FirmwareKit/EPM.h>
 #include <KernelKit/KPC.h>
 #include <KernelKit/ProcessScheduler.h>
-#include <KernelKit/User.h>
-#include <NewKit/Crc32.h>
-#include <NewKit/KString.h>
-#include <NewKit/KernelPanic.h>
-#include <NewKit/Utils.h>
+#include <KernelKit/UserMgr.h>
+#include <NeKit/Crc32.h>
+#include <NeKit/KString.h>
+#include <NeKit/KernelPanic.h>
+#include <NeKit/Utils.h>
 #include <modules/AHCI/AHCI.h>
 #include <modules/ATA/ATA.h>
 
diff --git a/dev/kernel/src/FS/HeFS+FileMgr.cc b/dev/kernel/src/FS/HeFS+FileMgr.cc
index e0b92a8d..e4985a3b 100644
--- a/dev/kernel/src/FS/HeFS+FileMgr.cc
+++ b/dev/kernel/src/FS/HeFS+FileMgr.cc
@@ -8,7 +8,7 @@
 #ifdef __FSKIT_INCLUDES_HEFS__
 
 #include <KernelKit/FileMgr.h>
-#include <KernelKit/MemoryMgr.h>
+#include <KernelKit/HeapMgr.h>
 
 #endif  // ifdef __FSKIT_INCLUDES_HEFS__
 #endif  // ifndef __NE_MINIMAL_OS__
diff --git a/dev/kernel/src/FS/HeFS+FileSystemParser.cc b/dev/kernel/src/FS/HeFS+FileSystemParser.cc
index a285593e..893f43ef 100644
--- a/dev/kernel/src/FS/HeFS+FileSystemParser.cc
+++ b/dev/kernel/src/FS/HeFS+FileSystemParser.cc
@@ -11,11 +11,11 @@
 #include <FirmwareKit/GPT.h>
 #include <KernelKit/KPC.h>
 #include <KernelKit/ProcessScheduler.h>
-#include <KernelKit/User.h>
-#include <NewKit/Crc32.h>
-#include <NewKit/KString.h>
-#include <NewKit/KernelPanic.h>
-#include <NewKit/Utils.h>
+#include <KernelKit/UserMgr.h>
+#include <NeKit/Crc32.h>
+#include <NeKit/KString.h>
+#include <NeKit/KernelPanic.h>
+#include <NeKit/Utils.h>
 #include <modules/AHCI/AHCI.h>
 #include <modules/ATA/ATA.h>
 
@@ -36,14 +36,14 @@ namespace Detail {
 
   /***********************************************************************************/
   /// @brief Get the index node of a file or directory.
-  /// @param root The root node of the filesystem.
+  /// @param boot The boot node of the filesystem.
   /// @param mnt The mnt to read from.
   /// @param dir_name The name of the directory.
   /// @param file_name The name of the file.
   /// @param kind The kind of the file (regular, directory, block, character, FIFO, socket, symbolic
   /// link, unknown).
   /***********************************************************************************/
-  STATIC ATTRIBUTE(unused) _Output HEFS_INDEX_NODE* hefsi_fetch_in(HEFS_BOOT_NODE* root,
+  STATIC ATTRIBUTE(unused) _Output HEFS_INDEX_NODE* hefsi_fetch_in(HEFS_BOOT_NODE* boot,
                                                                    DriveTrait*     mnt,
                                                                    const Utf8Char* dir_name,
                                                                    const Utf8Char* file_name,
@@ -51,31 +51,31 @@ namespace Detail {
 
   /***********************************************************************************/
   /// @brief Allocate a new index node->
-  /// @param root The root node of the filesystem.
+  /// @param boot The boot node of the filesystem.
   /// @param mnt The mnt to read/write from.
   /// @param dir_name The name of the parent directory.
   /// @return Status, see err_global_get().
   /***********************************************************************************/
   STATIC ATTRIBUTE(unused) _Output BOOL
-      hefsi_update_in_status(HEFS_BOOT_NODE* root, DriveTrait* mnt, const Utf8Char* dir_name,
+      hefsi_update_in_status(HEFS_BOOT_NODE* boot, DriveTrait* mnt, const Utf8Char* dir_name,
                              HEFS_INDEX_NODE* node, const BOOL create_or_delete);
 
   /***********************************************************************************/
   /// @brief Balance RB-Tree of the filesystem.
-  /// @param root The root node of the filesystem.
+  /// @param boot The boot node of the filesystem.
   /// @param mnt The mnt to read/write from.
   /// @return Status, see err_global_get().
   /***********************************************************************************/
-  STATIC ATTRIBUTE(unused) _Output BOOL hefsi_balance_ind(HEFS_BOOT_NODE* root, DriveTrait* mnt);
+  STATIC ATTRIBUTE(unused) _Output BOOL hefsi_balance_ind(HEFS_BOOT_NODE* boot, DriveTrait* mnt);
 
   /// @brief Alllocate IND from boot node.
-  /// @param root The root node of the filesystem.
+  /// @param boot The boot node of the filesystem.
   /// @param mnt The mnt to read from.
   /// @param dir_name The name of the directory.
   /// @param dir_name The parent of the directory.
   /// @param flags Directory flags.
   /// @param delete_or_create Delete or create directory.
-  STATIC _Output BOOL hefsi_update_ind_status(HEFS_BOOT_NODE* root, DriveTrait* mnt,
+  STATIC _Output BOOL hefsi_update_ind_status(HEFS_BOOT_NODE* boot, DriveTrait* mnt,
                                               const Utf8Char* dir_name, UInt16 flags,
                                               const BOOL delete_or_create);
 
@@ -251,24 +251,24 @@ namespace Detail {
   }
 
   /// @brief Alllocate IND from boot node.
-  /// @param root The root node of the filesystem.
+  /// @param boot The boot node of the filesystem.
   /// @param mnt The mnt to read from.
   /// @param dir_name The name of the directory.
   /// @param dir_name The parent of the directory.
   /// @param flags Directory flags.
   /// @param delete_or_create Delete or create directory.
-  STATIC _Output BOOL hefsi_update_ind_status(HEFS_BOOT_NODE* root, DriveTrait* mnt,
+  STATIC _Output BOOL hefsi_update_ind_status(HEFS_BOOT_NODE* boot, DriveTrait* mnt,
                                               const Utf8Char* dir_name, UInt16 flags,
                                               const BOOL delete_or_create) {
     if (mnt) {
       HEFS_INDEX_NODE_DIRECTORY* tmpdir =
-          (HEFS_INDEX_NODE_DIRECTORY*) mm_new_heap(sizeof(HEFS_INDEX_NODE_DIRECTORY), Yes, No);
+          (HEFS_INDEX_NODE_DIRECTORY*) mm_alloc_ptr(sizeof(HEFS_INDEX_NODE_DIRECTORY), Yes, No);
 
-      auto start           = root->fStartIND;
+      auto start           = boot->fStartIND;
       auto prev_location   = start;
       auto parent_location = 0UL;
 
-      MUST_PASS(root->fStartIND > mnt->fLbaStart);
+      MUST_PASS(boot->fStartIND > mnt->fLbaStart);
 
       while (YES) {
         auto prev_start = start;
@@ -294,7 +294,7 @@ namespace Detail {
 
         if (expr) {
           HEFS_INDEX_NODE_DIRECTORY* dirent =
-              (HEFS_INDEX_NODE_DIRECTORY*) mm_new_heap(sizeof(HEFS_INDEX_NODE_DIRECTORY), Yes, No);
+              (HEFS_INDEX_NODE_DIRECTORY*) mm_alloc_ptr(sizeof(HEFS_INDEX_NODE_DIRECTORY), Yes, No);
 
           rt_set_memory(dirent, 0, sizeof(HEFS_INDEX_NODE_DIRECTORY));
 
@@ -323,7 +323,7 @@ namespace Detail {
 
             if (tmpend->fChecksum !=
                 ke_calculate_crc32((Char*) tmpend, sizeof(HEFS_INDEX_NODE_DIRECTORY)))
-              ke_panic(RUNTIME_CHECK_FILESYSTEM, "Bad CRC32");
+              ke_panic(RUNTIME_CHECK_FILESYSTEM, "Bad CRC32 value, aborting.");
 
             if (delete_or_create)
               --tmpend->fEntryCount;
@@ -349,7 +349,7 @@ namespace Detail {
                 break;
               }
 
-              hefsi_traverse_tree(tmpend, mnt, root->fStartIND, child_first);
+              hefsi_traverse_tree(tmpend, mnt, boot->fStartIND, child_first);
             }
           }
 
@@ -364,11 +364,11 @@ namespace Detail {
           }
 
           if (dirent->fPrev == 0) {
-            dirent->fPrev = root->fStartIND;
+            dirent->fPrev = boot->fStartIND;
           }
 
           if (dirent->fParent == 0) {
-            dirent->fParent = root->fStartIND;
+            dirent->fParent = boot->fStartIND;
           }
 
           if (tmpdir->fChild == 0) {
@@ -389,13 +389,13 @@ namespace Detail {
               }
 
               child += sizeof(HEFS_INDEX_NODE_DIRECTORY);
-              if (child > root->fEndIND) break;
+              if (child > boot->fEndIND) break;
             }
 
             dirent->fColor = kHeFSRed;
             dirent->fChild = child;
 
-            if (child > root->fEndIND) dirent->fChild = root->fStartIND;
+            if (child > boot->fEndIND) dirent->fChild = boot->fStartIND;
           }
 
           for (SizeT index = 0UL; index < kHeFSSliceCount; ++index) {
@@ -412,19 +412,19 @@ namespace Detail {
 
           err_global_get() = kErrorSuccess;
 
-          mm_delete_heap(dirent);
-          mm_delete_heap(tmpdir);
+          mm_free_ptr(dirent);
+          mm_free_ptr(tmpdir);
 
           if (!delete_or_create)
-            ++root->fINDCount;
+            ++boot->fINDCount;
           else
-            --root->fINDCount;
+            --boot->fINDCount;
 
-          root->fChecksum = ke_calculate_crc32((Char*) root, sizeof(HEFS_BOOT_NODE));
+          boot->fChecksum = ke_calculate_crc32((Char*) boot, sizeof(HEFS_BOOT_NODE));
 
           mnt->fPacket.fPacketLba     = mnt->fLbaStart;
           mnt->fPacket.fPacketSize    = sizeof(HEFS_BOOT_NODE);
-          mnt->fPacket.fPacketContent = root;
+          mnt->fPacket.fPacketContent = boot;
 
           mnt->fOutput(mnt->fPacket);
 
@@ -433,12 +433,12 @@ namespace Detail {
 
         prev_location = start;
 
-        hefsi_traverse_tree(tmpdir, mnt, root->fStartIND, start);
-        if (start > root->fEndIND || start == 0) break;
+        hefsi_traverse_tree(tmpdir, mnt, boot->fStartIND, start);
+        if (start > boot->fEndIND || start == 0) break;
       }
 
       err_global_get() = kErrorDisk;
-      mm_delete_heap(tmpdir);
+      mm_free_ptr(tmpdir);
 
       return NO;
     }
@@ -448,26 +448,26 @@ namespace Detail {
   }
 
   /// @brief Get the index node of a file or directory.
-  /// @param root The root node of the filesystem.
+  /// @param boot The boot node of the filesystem.
   /// @param mnt The mnt to read from.
   /// @param dir_name The name of the directory.
   /// @param file_name The name of the file.
   /// @param kind The kind of the file (regular, directory, block, character, FIFO, socket, symbolic
   /// link, unknown).
-  STATIC ATTRIBUTE(unused) _Output HEFS_INDEX_NODE* hefsi_fetch_in(HEFS_BOOT_NODE* root,
+  STATIC ATTRIBUTE(unused) _Output HEFS_INDEX_NODE* hefsi_fetch_in(HEFS_BOOT_NODE* boot,
                                                                    DriveTrait*     mnt,
                                                                    const Utf8Char* dir_name,
                                                                    const Utf8Char* file_name,
                                                                    UInt8           kind) {
     if (mnt) {
-      if (root->fStartIND > root->fEndIND) return nullptr;
-      if (root->fStartIN > root->fEndIN) return nullptr;
+      if (boot->fStartIND > boot->fEndIND) return nullptr;
+      if (boot->fStartIN > boot->fEndIN) return nullptr;
 
-      auto             start = root->fStartIND;
+      auto             start = boot->fStartIND;
       HEFS_INDEX_NODE* node  = new HEFS_INDEX_NODE();
 
       HEFS_INDEX_NODE_DIRECTORY* dir =
-          (HEFS_INDEX_NODE_DIRECTORY*) mm_new_heap(sizeof(HEFS_INDEX_NODE_DIRECTORY), Yes, No);
+          (HEFS_INDEX_NODE_DIRECTORY*) mm_alloc_ptr(sizeof(HEFS_INDEX_NODE_DIRECTORY), Yes, No);
 
       while (YES) {
         if (err_global_get() == kErrorDiskIsCorrupted) {
@@ -511,8 +511,8 @@ namespace Detail {
           }
         }
 
-        hefsi_traverse_tree(dir, mnt, root->fStartIND, start);
-        if (start == root->fStartIND || start == root->fStartIND) break;
+        hefsi_traverse_tree(dir, mnt, boot->fStartIND, start);
+        if (start == boot->fStartIND || start == boot->fStartIND) break;
       }
 
       delete node;
@@ -530,20 +530,20 @@ namespace Detail {
   }
 
   STATIC ATTRIBUTE(unused) _Output BOOL
-      hefsi_update_in_status(HEFS_BOOT_NODE* root, DriveTrait* mnt, const Utf8Char* dir_name,
+      hefsi_update_in_status(HEFS_BOOT_NODE* boot, DriveTrait* mnt, const Utf8Char* dir_name,
                              HEFS_INDEX_NODE* node, BOOL delete_or_create) {
-    if (!root || !mnt) return NO;
+    if (!boot || !mnt) return NO;
 
-    auto start = root->fStartIND;
+    auto start = boot->fStartIND;
 
-    if (start > root->fEndIND) return NO;
-    if (root->fStartIN > root->fEndIN) return NO;
+    if (start > boot->fEndIND) return NO;
+    if (boot->fStartIN > boot->fEndIN) return NO;
     ;
-    if (root->fStartBlock > root->fEndBlock) return NO;
+    if (boot->fStartBlock > boot->fEndBlock) return NO;
 
     if (mnt) {
       HEFS_INDEX_NODE_DIRECTORY* dir =
-          (HEFS_INDEX_NODE_DIRECTORY*) mm_new_heap(sizeof(HEFS_INDEX_NODE_DIRECTORY), Yes, No);
+          (HEFS_INDEX_NODE_DIRECTORY*) mm_alloc_ptr(sizeof(HEFS_INDEX_NODE_DIRECTORY), Yes, No);
 
       auto hash_file = node->fHashPath;
 
@@ -560,7 +560,7 @@ namespace Detail {
         if (hefsi_hash_64(dir_name) == dir->fHashPath) {
           for (SizeT inode_index = 0UL; inode_index < kHeFSSliceCount; ++inode_index) {
             if (dir->fINSlices[inode_index] == 0 && !delete_or_create) {
-              dir->fINSlices[inode_index] = root->fStartIN;
+              dir->fINSlices[inode_index] = boot->fStartIN;
 
               ++dir->fEntryCount;
 
@@ -574,8 +574,8 @@ namespace Detail {
 
               auto lba = dir->fINSlices[inode_index];
 
-              node->fOffsetSliceLow  = (UInt32) (root->fStartBlock);
-              node->fOffsetSliceHigh = (UInt32) (root->fStartBlock >> 32);
+              node->fOffsetSliceLow  = (UInt32) (boot->fStartBlock);
+              node->fOffsetSliceHigh = (UInt32) (boot->fStartBlock >> 32);
 
               node->fChecksum = ke_calculate_crc32((Char*) node, sizeof(HEFS_INDEX_NODE));
 
@@ -585,18 +585,18 @@ namespace Detail {
 
               mnt->fOutput(mnt->fPacket);
 
-              root->fStartIN += sizeof(HEFS_INDEX_NODE);
-              root->fStartBlock += kHeFSBlockLen;
+              boot->fStartIN += sizeof(HEFS_INDEX_NODE);
+              boot->fStartBlock += kHeFSBlockLen;
 
-              root->fChecksum = ke_calculate_crc32((Char*) root, sizeof(HEFS_BOOT_NODE));
+              boot->fChecksum = ke_calculate_crc32((Char*) boot, sizeof(HEFS_BOOT_NODE));
 
               mnt->fPacket.fPacketLba     = mnt->fLbaStart;
               mnt->fPacket.fPacketSize    = sizeof(HEFS_BOOT_NODE);
-              mnt->fPacket.fPacketContent = root;
+              mnt->fPacket.fPacketContent = boot;
 
               mnt->fOutput(mnt->fPacket);
 
-              mm_delete_heap(dir);
+              mm_free_ptr(dir);
 
               return YES;
             } else if (dir->fINSlices[inode_index] != 0 && delete_or_create) {
@@ -617,14 +617,14 @@ namespace Detail {
               node->fOffsetSliceLow  = 0;
               node->fOffsetSliceHigh = 0;
 
-              root->fStartIN -= sizeof(HEFS_INDEX_NODE);
-              root->fStartBlock -= kHeFSBlockLen;
+              boot->fStartIN -= sizeof(HEFS_INDEX_NODE);
+              boot->fStartBlock -= kHeFSBlockLen;
 
-              root->fChecksum = ke_calculate_crc32((Char*) root, sizeof(HEFS_BOOT_NODE));
+              boot->fChecksum = ke_calculate_crc32((Char*) boot, sizeof(HEFS_BOOT_NODE));
 
               mnt->fPacket.fPacketLba     = mnt->fLbaStart;
               mnt->fPacket.fPacketSize    = sizeof(HEFS_BOOT_NODE);
-              mnt->fPacket.fPacketContent = root;
+              mnt->fPacket.fPacketContent = boot;
 
               mnt->fOutput(mnt->fPacket);
 
@@ -646,18 +646,18 @@ namespace Detail {
 
               mnt->fOutput(mnt->fPacket);
 
-              mm_delete_heap(dir);
+              mm_free_ptr(dir);
 
               return YES;
             }
           }
         }
 
-        hefsi_traverse_tree(dir, mnt, root->fStartIND, start);
-        if (start > root->fEndIND || start == 0) break;
+        hefsi_traverse_tree(dir, mnt, boot->fStartIND, start);
+        if (start > boot->fEndIND || start == 0) break;
       }
 
-      mm_delete_heap(dir);
+      mm_free_ptr(dir);
       err_global_get() = kErrorFileNotFound;
       return NO;
     }
@@ -667,18 +667,18 @@ namespace Detail {
   }
 
   /// @brief Balance RB-Tree of the filesystem.
-  /// @param root The root node of the filesystem.
+  /// @param boot The boot node of the filesystem.
   /// @param mnt The mnt to read/write from.
   /// @return Status, see err_global_get().
-  STATIC ATTRIBUTE(unused) _Output BOOL hefsi_balance_ind(HEFS_BOOT_NODE* root, DriveTrait* mnt) {
+  STATIC ATTRIBUTE(unused) _Output BOOL hefsi_balance_ind(HEFS_BOOT_NODE* boot, DriveTrait* mnt) {
     if (mnt) {
       HEFS_INDEX_NODE_DIRECTORY* dir =
           (HEFS_INDEX_NODE_DIRECTORY*) RTL_ALLOCA(sizeof(HEFS_INDEX_NODE_DIRECTORY));
 
-      auto start = root->fStartIND;
+      auto start = boot->fStartIND;
 
       while (YES) {
-        if (start == 0UL || start > root->fEndIND) break;
+        if (start == 0UL || start > boot->fEndIND) break;
 
         mnt->fPacket.fPacketLba     = start;
         mnt->fPacket.fPacketSize    = sizeof(HEFS_INDEX_NODE_DIRECTORY);
@@ -692,7 +692,7 @@ namespace Detail {
           return NO;
         }
 
-        if (start == root->fStartIND) {
+        if (start == boot->fStartIND) {
           dir->fColor = kHeFSBlack;
 
           mnt->fPacket.fPacketLba     = start;
@@ -725,7 +725,7 @@ namespace Detail {
           mnt->fOutput(mnt->fPacket);
         }
 
-        hefsi_traverse_tree(dir, mnt, root->fStartIND, start);
+        hefsi_traverse_tree(dir, mnt, boot->fStartIND, start);
       }
 
       err_global_get() = kErrorSuccess;
@@ -742,7 +742,7 @@ namespace Detail {
 /// real-time.
 /// @note This is certainly take longer to format a disk with it, but worth-it in the long run.
 
-namespace Kernel::HeFS {
+namespace Kernel {
 /// @brief Make a EPM+HeFS mnt out of the disk.
 /// @param mnt The mnt to write on.
 /// @return If it was sucessful, see err_local_get().
@@ -758,16 +758,15 @@ _Output Bool HeFileSystemParser::Format(_Input _Output DriveTrait* mnt, _Input c
   }
 
   if (drv_std_get_size() < kHeFSMinimumDiskSize) {
-    kout << "HeFS requires at least 128 GiB." << kendl;
-    err_global_get() = kErrorDisk;
-    return NO;
+    (Void)(kout << "HeFS recommends at least 128 GiB of free space." << kendl);
+    (Void)(kout << "The OS will still try to format a HeFS disk here." << kendl);
   }
 
-  HEFS_BOOT_NODE* root = (HEFS_BOOT_NODE*) RTL_ALLOCA(sizeof(HEFS_BOOT_NODE));
+  HEFS_BOOT_NODE* boot = (HEFS_BOOT_NODE*) RTL_ALLOCA(sizeof(HEFS_BOOT_NODE));
 
   mnt->fPacket.fPacketLba     = mnt->fLbaStart;
   mnt->fPacket.fPacketSize    = sizeof(HEFS_BOOT_NODE);
-  mnt->fPacket.fPacketContent = root;
+  mnt->fPacket.fPacketContent = boot;
 
   mnt->fInput(mnt->fPacket);
 
@@ -779,9 +778,9 @@ _Output Bool HeFileSystemParser::Format(_Input _Output DriveTrait* mnt, _Input c
 
   // Check if the disk is already formatted.
 
-  if (KStringBuilder::Equals(root->fMagic, kHeFSMagic) && root->fVersion == kHeFSVersion) {
-    if (ke_calculate_crc32((Char*) root, sizeof(HEFS_BOOT_NODE)) != root->fChecksum &&
-        root->fChecksum > 0) {
+  if (KStringBuilder::Equals(boot->fMagic, kHeFSMagic) && boot->fVersion == kHeFSVersion) {
+    if (ke_calculate_crc32((Char*) boot, sizeof(HEFS_BOOT_NODE)) != boot->fChecksum &&
+        boot->fChecksum > 0) {
       err_global_get() = kErrorDiskIsCorrupted;
       return NO;
     }
@@ -790,8 +789,8 @@ _Output Bool HeFileSystemParser::Format(_Input _Output DriveTrait* mnt, _Input c
     return YES;
   }
 
-  if (ke_calculate_crc32((Char*) root, sizeof(HEFS_BOOT_NODE)) != root->fChecksum &&
-      root->fChecksum > 0) {
+  if (ke_calculate_crc32((Char*) boot, sizeof(HEFS_BOOT_NODE)) != boot->fChecksum &&
+      boot->fChecksum > 0) {
     err_global_get() = kErrorDiskIsCorrupted;
     return NO;
   }
@@ -799,8 +798,8 @@ _Output Bool HeFileSystemParser::Format(_Input _Output DriveTrait* mnt, _Input c
   rt_copy_memory((VoidPtr) "fs/hefs-packet", mnt->fPacket.fPacketMime,
                  rt_string_len("fs/hefs-packet"));
 
-  urt_copy_memory((VoidPtr) vol_name, root->fVolName, urt_string_len(vol_name) + 1);
-  rt_copy_memory((VoidPtr) kHeFSMagic, root->fMagic, kHeFSMagicLen - 1);
+  urt_copy_memory((VoidPtr) vol_name, boot->fVolName, urt_string_len(vol_name) + 1);
+  rt_copy_memory((VoidPtr) kHeFSMagic, boot->fMagic, kHeFSMagicLen - 1);
 
   if (mnt->fLbaStart > mnt->fLbaEnd) {
     err_global_get() = kErrorDiskIsCorrupted;
@@ -808,66 +807,66 @@ _Output Bool HeFileSystemParser::Format(_Input _Output DriveTrait* mnt, _Input c
     return NO;
   }
 
-  root->fBadSectors = 0;
+  boot->fBadSectors = 0;
 
-  root->fSectorCount = drv_std_get_sector_count();
-  root->fSectorSize  = mnt->fSectorSz;
+  boot->fSectorCount = drv_std_get_sector_count();
+  boot->fSectorSize  = mnt->fSectorSz;
 
-  MUST_PASS(root->fSectorSize);
+  MUST_PASS(boot->fSectorSize);
 
   /// @note all HeFS strucutres are equal to 512, so here it's fine, unless fSectoSize is 2048.
-  const SizeT max_lba = (drv_std_get_size()) / root->fSectorSize;
+  const SizeT max_lba = (drv_std_get_size()) / boot->fSectorSize;
 
   const SizeT dir_max   = max_lba / 300;  // 5% for directory inodes
   const SizeT inode_max = max_lba / 400;  // 5% for inodes
 
-  root->fStartIND = mnt->fLbaStart + kHeFSINDStartOffset;
-  root->fEndIND   = root->fStartIND + dir_max;
+  boot->fStartIND = mnt->fLbaStart + kHeFSINDStartOffset;
+  boot->fEndIND   = boot->fStartIND + dir_max;
 
-  root->fStartIN = root->fEndIND;
-  root->fEndIN   = root->fStartIN + inode_max;
+  boot->fStartIN = boot->fEndIND;
+  boot->fEndIN   = boot->fStartIN + inode_max;
 
-  root->fStartBlock = root->fEndIN;
-  root->fEndBlock   = drv_std_get_size();
+  boot->fStartBlock = boot->fEndIN;
+  boot->fEndBlock   = drv_std_get_size();
 
-  root->fINDCount = 0;
+  boot->fINDCount = 0;
 
-  root->fDiskSize   = drv_std_get_size();
-  root->fDiskStatus = kHeFSStatusUnlocked;
+  boot->fDiskSize   = drv_std_get_size();
+  boot->fDiskStatus = kHeFSStatusUnlocked;
 
-  root->fDiskFlags = flags;
+  boot->fDiskFlags = flags;
 
   if (mnt->fKind & kMassStorageDrive) {
-    root->fDiskKind = kHeFSMassStorageDevice;
+    boot->fDiskKind = kHeFSMassStorageDevice;
   } else if (mnt->fKind & kHeFSOpticalDrive) {
-    root->fDiskKind = kHeFSOpticalDrive;
+    boot->fDiskKind = kHeFSOpticalDrive;
   } else {
-    root->fDiskKind = kHeFSUnknown;
+    boot->fDiskKind = kHeFSUnknown;
   }
 
-  root->fVersion = kHeFSVersion;
+  boot->fVersion = kHeFSVersion;
 
-  root->fVID = kHeFSInvalidVID;
+  boot->fVID = kHeFSInvalidVID;
 
-  root->fChecksum = ke_calculate_crc32((Char*) root, sizeof(HEFS_BOOT_NODE));
+  boot->fChecksum = ke_calculate_crc32((Char*) boot, sizeof(HEFS_BOOT_NODE));
 
   mnt->fPacket.fPacketLba     = mnt->fLbaStart;
   mnt->fPacket.fPacketSize    = sizeof(HEFS_BOOT_NODE);
-  mnt->fPacket.fPacketContent = root;
+  mnt->fPacket.fPacketContent = boot;
 
   mnt->fOutput(mnt->fPacket);
 
   (Void)(kout << "Protocol: " << mnt->fProtocol() << kendl);
-  (Void)(kout8 << u8"Volume Name: " << root->fVolName << kendl8);
-  (Void)(kout << "Start IND: " << hex_number(root->fStartIND) << kendl);
-  (Void)(kout << "End IND: " << hex_number(root->fEndIND) << kendl);
-  (Void)(kout << "Start IN: " << hex_number(root->fStartIN) << kendl);
-  (Void)(kout << "End IN: " << hex_number(root->fEndIN) << kendl);
-  (Void)(kout << "Start Block: " << hex_number(root->fStartBlock) << kendl);
-  (Void)(kout << "End Block: " << hex_number(root->fEndBlock) << kendl);
-  (Void)(kout << "Number of IND: " << hex_number(root->fINDCount) << kendl);
-  (Void)(kout << "Sector Size: " << hex_number(root->fSectorSize) << kendl);
-  (Void)(kout << "Drive Kind: " << Detail::hefs_drive_kind_to_string(root->fDiskKind) << kendl);
+  (Void)(kout8 << u8"Volume Name: " << boot->fVolName << kendl8);
+  (Void)(kout << "Start IND: " << hex_number(boot->fStartIND) << kendl);
+  (Void)(kout << "End IND: " << hex_number(boot->fEndIND) << kendl);
+  (Void)(kout << "Start IN: " << hex_number(boot->fStartIN) << kendl);
+  (Void)(kout << "End IN: " << hex_number(boot->fEndIN) << kendl);
+  (Void)(kout << "Start Block: " << hex_number(boot->fStartBlock) << kendl);
+  (Void)(kout << "End Block: " << hex_number(boot->fEndBlock) << kendl);
+  (Void)(kout << "Number of IND: " << hex_number(boot->fINDCount) << kendl);
+  (Void)(kout << "Sector Size: " << hex_number(boot->fSectorSize) << kendl);
+  (Void)(kout << "Drive Kind: " << Detail::hefs_drive_kind_to_string(boot->fDiskKind) << kendl);
 
   if (!mnt->fPacket.fPacketGood) {
     err_global_get() = kErrorDiskIsCorrupted;
@@ -902,23 +901,23 @@ _Output Bool HeFileSystemParser::INodeDirectoryCtlManip(_Input DriveTrait* mnt,
     return NO;
   }
 
-  HEFS_BOOT_NODE* root = (HEFS_BOOT_NODE*) mm_new_heap(sizeof(HEFS_BOOT_NODE), Yes, No);
+  HEFS_BOOT_NODE* boot = (HEFS_BOOT_NODE*) mm_alloc_ptr(sizeof(HEFS_BOOT_NODE), Yes, No);
 
   rt_copy_memory((VoidPtr) "fs/hefs-packet", mnt->fPacket.fPacketMime,
                  rt_string_len("fs/hefs-packet"));
 
   mnt->fPacket.fPacketLba     = mnt->fLbaStart;
   mnt->fPacket.fPacketSize    = sizeof(HEFS_BOOT_NODE);
-  mnt->fPacket.fPacketContent = root;
+  mnt->fPacket.fPacketContent = boot;
 
   mnt->fInput(mnt->fPacket);
 
-  if (!KStringBuilder::Equals(root->fMagic, kHeFSMagic) || root->fVersion != kHeFSVersion) {
+  if (!KStringBuilder::Equals(boot->fMagic, kHeFSMagic) || boot->fVersion != kHeFSVersion) {
     err_global_get() = kErrorDisk;
     return YES;
   }
 
-  if (!KStringBuilder::Equals(root->fMagic, kHeFSMagic) || root->fVersion != kHeFSVersion) {
+  if (!KStringBuilder::Equals(boot->fMagic, kHeFSMagic) || boot->fVersion != kHeFSVersion) {
     err_global_get() = kErrorDiskIsCorrupted;
 
     kout << "Invalid Boot Node, this can't continue!\r";
@@ -934,15 +933,15 @@ _Output Bool HeFileSystemParser::INodeDirectoryCtlManip(_Input DriveTrait* mnt,
     return NO;
   }
 
-  if (Detail::hefsi_update_ind_status(root, mnt, dir, flags, delete_or_create)) {
+  if (Detail::hefsi_update_ind_status(boot, mnt, dir, flags, delete_or_create)) {
     // todo: make it smarter for high-throughput.
-    Detail::hefsi_balance_ind(root, mnt);
+    Detail::hefsi_balance_ind(boot, mnt);
 
-    mm_delete_heap((VoidPtr) root);
+    mm_free_ptr((VoidPtr) boot);
     return YES;
   }
 
-  mm_delete_heap((VoidPtr) root);
+  mm_free_ptr((VoidPtr) boot);
   return NO;
 }
 
@@ -983,9 +982,9 @@ _Output Bool HeFileSystemParser::INodeManip(_Input DriveTrait* mnt, VoidPtr bloc
     return NO;
   }
 
-  HEFS_BOOT_NODE* root = (HEFS_BOOT_NODE*) mm_new_heap(sizeof(HEFS_BOOT_NODE), Yes, No);
+  HEFS_BOOT_NODE* boot = (HEFS_BOOT_NODE*) mm_alloc_ptr(sizeof(HEFS_BOOT_NODE), Yes, No);
 
-  if (!root) {
+  if (!boot) {
     err_global_get() = kErrorInvalidData;
     return NO;
   }
@@ -995,18 +994,18 @@ _Output Bool HeFileSystemParser::INodeManip(_Input DriveTrait* mnt, VoidPtr bloc
 
   mnt->fPacket.fPacketLba     = mnt->fLbaStart;
   mnt->fPacket.fPacketSize    = sizeof(HEFS_BOOT_NODE);
-  mnt->fPacket.fPacketContent = root;
+  mnt->fPacket.fPacketContent = boot;
 
   mnt->fInput(mnt->fPacket);
 
-  if (!KStringBuilder::Equals(root->fMagic, kHeFSMagic) || root->fVersion != kHeFSVersion) {
+  if (!KStringBuilder::Equals(boot->fMagic, kHeFSMagic) || boot->fVersion != kHeFSVersion) {
     (Void)(kout << "Invalid Boot Node, HeFS partition is invalid." << kendl);
-    mm_delete_heap((VoidPtr) root);
+    mm_free_ptr((VoidPtr) boot);
     err_global_get() = kErrorDisk;
     return NO;
   }
 
-  auto start = Detail::hefsi_fetch_in(root, mnt, dir, name, kind);
+  auto start = Detail::hefsi_fetch_in(boot, mnt, dir, name, kind);
 
   if (start) {
     (Void)(kout << hex_number(start->fHashPath) << kendl);
@@ -1021,7 +1020,7 @@ _Output Bool HeFileSystemParser::INodeManip(_Input DriveTrait* mnt, VoidPtr bloc
         mnt->fInput(mnt->fPacket);
       } else {
         if (start->fFlags & kHeFSFlagsReadOnly) {
-          mm_delete_heap((VoidPtr) root);
+          mm_free_ptr((VoidPtr) boot);
           delete start;
 
           kout << "Error: File is read-only\r";
@@ -1034,7 +1033,7 @@ _Output Bool HeFileSystemParser::INodeManip(_Input DriveTrait* mnt, VoidPtr bloc
     }
   }
 
-  mm_delete_heap((VoidPtr) root);
+  mm_free_ptr((VoidPtr) boot);
   delete start;
   return YES;
 }
@@ -1058,7 +1057,7 @@ _Output Bool HeFileSystemParser::INodeCtlManip(_Input DriveTrait* mnt, _Input co
     return NO;
   }
 
-  HEFS_INDEX_NODE* node = (HEFS_INDEX_NODE*) mm_new_heap(sizeof(HEFS_INDEX_NODE), Yes, No);
+  HEFS_INDEX_NODE* node = (HEFS_INDEX_NODE*) mm_alloc_ptr(sizeof(HEFS_INDEX_NODE), Yes, No);
 
   if (!node) {
     err_global_get() = kErrorInvalidData;
@@ -1067,10 +1066,10 @@ _Output Bool HeFileSystemParser::INodeCtlManip(_Input DriveTrait* mnt, _Input co
 
   rt_set_memory(node, 0, sizeof(HEFS_INDEX_NODE));
 
-  HEFS_BOOT_NODE* root = (HEFS_BOOT_NODE*) RTL_ALLOCA(sizeof(HEFS_BOOT_NODE));
+  HEFS_BOOT_NODE* boot = (HEFS_BOOT_NODE*) RTL_ALLOCA(sizeof(HEFS_BOOT_NODE));
 
-  if (!root) {
-    mm_delete_heap((VoidPtr) node);
+  if (!boot) {
+    mm_free_ptr((VoidPtr) node);
     err_global_get() = kErrorInvalidData;
 
     return NO;
@@ -1081,11 +1080,11 @@ _Output Bool HeFileSystemParser::INodeCtlManip(_Input DriveTrait* mnt, _Input co
 
   mnt->fPacket.fPacketLba     = mnt->fLbaStart;
   mnt->fPacket.fPacketSize    = sizeof(HEFS_BOOT_NODE);
-  mnt->fPacket.fPacketContent = root;
+  mnt->fPacket.fPacketContent = boot;
 
   mnt->fInput(mnt->fPacket);
 
-  if (!KStringBuilder::Equals(root->fMagic, kHeFSMagic) || root->fVersion != kHeFSVersion) {
+  if (!KStringBuilder::Equals(boot->fMagic, kHeFSMagic) || boot->fVersion != kHeFSVersion) {
     err_global_get() = kErrorDisk;
     return YES;
   }
@@ -1112,8 +1111,8 @@ _Output Bool HeFileSystemParser::INodeCtlManip(_Input DriveTrait* mnt, _Input co
   }
 
   node->fAccessed = 0;
-  node->fCreated  = delete_or_create ? 0UL : 1UL;
-  node->fDeleted  = delete_or_create ? 1UL : 0UL;
+  node->fCreated  = delete_or_create ? NO : YES;
+  node->fDeleted  = delete_or_create ? 1UL : NO;
   node->fModified = 0;
   node->fSize     = 0;
   node->fKind     = kind;
@@ -1123,16 +1122,16 @@ _Output Bool HeFileSystemParser::INodeCtlManip(_Input DriveTrait* mnt, _Input co
   node->fUID      = 0;
   node->fHashPath = Detail::hefsi_hash_64(name);
 
-  if (Detail::hefsi_update_in_status(root, mnt, dir, node, delete_or_create)) {
-    mm_delete_heap((VoidPtr) node);
+  if (Detail::hefsi_update_in_status(boot, mnt, dir, node, delete_or_create)) {
+    mm_free_ptr((VoidPtr) node);
 
-    Detail::hefsi_balance_ind(root, mnt);
+    Detail::hefsi_balance_ind(boot, mnt);
 
     err_global_get() = kErrorSuccess;
     return YES;
   }
 
-  mm_delete_heap((VoidPtr) node);
+  mm_free_ptr((VoidPtr) node);
   err_global_get() = kErrorDirectoryNotFound;
 
   return NO;
@@ -1142,7 +1141,7 @@ STATIC DriveTrait kMountPoint;
 
 /// @brief Initialize the HeFS filesystem.
 /// @return To check its status, see err_local_get().
-Boolean fs_init_hefs(Void) {
+Boolean HeFS::fs_init_hefs(Void) noexcept {
   kout << "Creating HeFS disk...\r";
 
   kMountPoint = io_construct_main_drive();
@@ -1152,10 +1151,8 @@ Boolean fs_init_hefs(Void) {
 
   HeFileSystemParser parser;
 
-  parser.Format(&kMountPoint, kHeFSEncodingFlagsUTF8, kHeFSDefaultVolumeName);
-
-  return YES;
+  return parser.Format(&kMountPoint, kHeFSEncodingFlagsUTF8, kHeFSDefaultVolumeName);
 }
-}  // namespace Kernel::HeFS
+}  // namespace Kernel
 
 #endif  // ifdef __FSKIT_INCLUDES_HEFS__
diff --git a/dev/kernel/src/FS/NeFS+FileMgr.cc b/dev/kernel/src/FS/NeFS+FileMgr.cc
index c92d6727..978a43a8 100644
--- a/dev/kernel/src/FS/NeFS+FileMgr.cc
+++ b/dev/kernel/src/FS/NeFS+FileMgr.cc
@@ -8,7 +8,7 @@
 #ifdef __FSKIT_INCLUDES_NEFS__
 
 #include <KernelKit/FileMgr.h>
-#include <KernelKit/MemoryMgr.h>
+#include <KernelKit/HeapMgr.h>
 
 /// @brief NeFS File System Manager.
 /// BUGS: 0
diff --git a/dev/kernel/src/FS/NeFS+FileSystemParser.cc b/dev/kernel/src/FS/NeFS+FileSystemParser.cc
index 0b818bbb..dd0a1d9a 100644
--- a/dev/kernel/src/FS/NeFS+FileSystemParser.cc
+++ b/dev/kernel/src/FS/NeFS+FileSystemParser.cc
@@ -10,13 +10,14 @@
 #include <FirmwareKit/EPM.h>
 
 #include <KernelKit/DriveMgr.h>
+#include <KernelKit/IFS.h>
 #include <KernelKit/KPC.h>
 #include <KernelKit/ProcessScheduler.h>
-#include <KernelKit/User.h>
-#include <NewKit/Crc32.h>
-#include <NewKit/KString.h>
-#include <NewKit/KernelPanic.h>
-#include <NewKit/Utils.h>
+#include <KernelKit/UserMgr.h>
+#include <NeKit/Crc32.h>
+#include <NeKit/KString.h>
+#include <NeKit/KernelPanic.h>
+#include <NeKit/Utils.h>
 #include <modules/AHCI/AHCI.h>
 #include <modules/ATA/ATA.h>
 
@@ -240,7 +241,7 @@ _Output NEFS_CATALOG_STRUCT* NeFileSystemParser::CreateCatalog(_Input const Char
     return nullptr;
   }
 
-  Char* parent_name = (Char*) mm_new_heap(sizeof(Char) * rt_string_len(name), Yes, No);
+  Char* parent_name = (Char*) mm_alloc_ptr(sizeof(Char) * rt_string_len(name), Yes, No);
 
   /// Locate parent catalog, to then allocate right after it.
 
@@ -269,7 +270,7 @@ _Output NEFS_CATALOG_STRUCT* NeFileSystemParser::CreateCatalog(_Input const Char
 
   NEFS_CATALOG_STRUCT* catalog = this->FindCatalog(parent_name, out_lba);
 
-  mm_delete_heap(parent_name);
+  mm_free_ptr(parent_name);
 
   auto& drive = kMountpoint.A();
 
@@ -444,6 +445,8 @@ bool NeFileSystemParser::Format(_Input _Output DriveTrait* drive, _Input const I
 
   NEFS_ROOT_PARTITION_BLOCK* part_block = (NEFS_ROOT_PARTITION_BLOCK*) fs_buf;
 
+  if (rt_string_cmp(kNeFSIdent, part_block->Ident, kNeFSIdentLen) == 0) return true;
+
   const auto kNeFSUntitledHD = part_name;
 
   rt_copy_memory((VoidPtr) kNeFSIdent, (VoidPtr) part_block->Ident, kNeFSIdentLen);
@@ -463,6 +466,7 @@ bool NeFileSystemParser::Format(_Input _Output DriveTrait* drive, _Input const I
   part_block->FreeSectors  = sectorCount / sizeof(NEFS_CATALOG_STRUCT) - 1;
   part_block->SectorCount  = sectorCount;
   part_block->DiskSize     = diskSize;
+  part_block->SectorSize   = drive->fSectorSz;
   part_block->FreeCatalog  = sectorCount / sizeof(NEFS_CATALOG_STRUCT) - 1;
 
   drive->fPacket.fPacketContent = fs_buf;
@@ -479,26 +483,6 @@ bool NeFileSystemParser::Format(_Input _Output DriveTrait* drive, _Input const I
   (Void)(kout << "Free sectors: " << hex_number(part_block->FreeSectors) << kendl);
   (Void)(kout << "Sector size: " << hex_number(part_block->SectorSize) << kendl);
 
-  NEFS_CATALOG_STRUCT root{};
-
-  rt_set_memory(&root, 0, sizeof(NEFS_CATALOG_STRUCT));
-
-  root.PrevSibling = part_block->StartCatalog;
-  root.NextSibling = 0UL;
-
-  root.Kind = kNeFSCatalogKindDir;
-  root.Flags |= kNeFSFlagCreated;
-  root.CatalogFlags |= kNeFSStatusUnlocked;
-
-  root.Name[0] = '/';
-  root.Name[1] = 0;
-
-  drive->fPacket.fPacketLba     = part_block->StartCatalog;
-  drive->fPacket.fPacketSize    = sizeof(NEFS_CATALOG_STRUCT);
-  drive->fPacket.fPacketContent = &root;
-
-  drive->fOutput(drive->fPacket);
-
   return true;
 }
 
@@ -895,7 +879,7 @@ namespace Kernel::NeFS {
 /// @brief Construct NeFS drives.
 /***********************************************************************************/
 Boolean fs_init_nefs(Void) noexcept {
-  kout << "Creating main disk...\r";
+  kout << "Creating HeFS disk...\r";
 
   kMountpoint.A() = io_construct_main_drive();
 
@@ -903,9 +887,8 @@ Boolean fs_init_nefs(Void) noexcept {
     ke_panic(RUNTIME_CHECK_FILESYSTEM, "Main disk cannot be mounted.");
 
   NeFileSystemParser parser;
-  parser.Format(&kMountpoint.A(), 0, kNeFSVolumeName);
 
-  return YES;
+  return parser.Format(&kMountpoint.A(), 0, kNeFSVolumeName);
 }
 }  // namespace Kernel::NeFS