dev(kernel, HeFS): reworking filesystem to find an hybrid solution regarding memory footprint (unstable changes)

Signed-off-by: Amlal <amlal@nekernel.org>

6 files changed, 285 insertions, 269 deletions

diff --git a/dev/kernel/HALKit/AMD64/HalDebugOutput.cc b/dev/kernel/HALKit/AMD64/HalDebugOutput.cc
index 5d09f8b4..34b99ffe 100644
--- a/dev/kernel/HALKit/AMD64/HalDebugOutput.cc
+++ b/dev/kernel/HALKit/AMD64/HalDebugOutput.cc
@@ -13,15 +13,15 @@
 
 namespace Kernel {
 enum CommStatus : UInt16 {
-  kStateInvalid = 0x64,
+  kStateInvalid  = 0x64,
   kStateReady    = 0xCF,
   kStateTransmit = 0xFC,
   kStateCnt      = 3
 };
 
 namespace Detail {
-  constexpr ATTRIBUTE(unused) const UInt16 kPort  = 0x3F8;
-  STATIC ATTRIBUTE(unused) UInt16          kState = kStateInvalid;
+  constexpr ATTRIBUTE(unused) const UInt16 kPort = 0x3F8;
+  STATIC ATTRIBUTE(unused) UInt16 kState         = kStateInvalid;
 
   /// @brief Init COM1.
   /// @return
diff --git a/dev/kernel/HALKit/AMD64/Storage/AHCI+Generic.cc b/dev/kernel/HALKit/AMD64/Storage/AHCI+Generic.cc
index b767e79c..d09fd71a 100644
--- a/dev/kernel/HALKit/AMD64/Storage/AHCI+Generic.cc
+++ b/dev/kernel/HALKit/AMD64/Storage/AHCI+Generic.cc
@@ -130,6 +130,11 @@ STATIC Void drv_std_input_output_ahci(UInt64 lba, UInt8* buffer, SizeT sector_sz
 
   lba /= sector_sz;
 
+  if (lba > kSATASectorCount) {
+    err_global_get() = kErrorDisk;
+    return;
+  }
+
   if (!buffer || size_buffer == 0) {
     kout << "Invalid buffer for AHCI I/O.\r";
     err_global_get() = kErrorDisk;
@@ -146,7 +151,7 @@ STATIC Void drv_std_input_output_ahci(UInt64 lba, UInt8* buffer, SizeT sector_sz
 
   volatile HbaCmdHeader* command_header =
       (volatile HbaCmdHeader*) ((UInt64) kSATAHba->Ports[kSATAIndex].Clb);
-      
+
   command_header += slot;
 
   MUST_PASS(command_header);
@@ -196,7 +201,7 @@ STATIC Void drv_std_input_output_ahci(UInt64 lba, UInt8* buffer, SizeT sector_sz
     return;
   }
 
-  command_header->Prdtl       = prdt_index;
+  command_header->Prdtl                 = prdt_index;
   command_header->HbaFlags.Struct.Cfl   = sizeof(FisRegH2D) / sizeof(UInt32);
   command_header->HbaFlags.Struct.Write = Write;
 
@@ -241,6 +246,7 @@ STATIC Void drv_std_input_output_ahci(UInt64 lba, UInt8* buffer, SizeT sector_sz
 
     rtl_dma_free(size_buffer);
     err_global_get() = kErrorDiskIsCorrupted;
+
     return;
   } else {
     if (!Write) {
diff --git a/dev/kernel/KernelKit/DriveMgr.h b/dev/kernel/KernelKit/DriveMgr.h
index d287a345..7972ac74 100644
--- a/dev/kernel/KernelKit/DriveMgr.h
+++ b/dev/kernel/KernelKit/DriveMgr.h
@@ -64,10 +64,10 @@ struct DriveTrait final {
   Lba   fLbaStart{0}, fLbaEnd{0};
   SizeT fSectorSz{kDriveSectorSz};
 
-  Void (*fInput)(DrivePacket packet);
-  Void (*fOutput)(DrivePacket packet);
-  Void (*fVerify)(DrivePacket packet);
-  Void (*fInit)(DrivePacket packet);
+  Void (*fInput)(DrivePacket& packet);
+  Void (*fOutput)(DrivePacket& packet);
+  Void (*fVerify)(DrivePacket& packet);
+  Void (*fInit)(DrivePacket& packet);
   const Char* (*fProtocol)(Void);
 };
 
diff --git a/dev/kernel/src/DriveMgr.cc b/dev/kernel/src/DriveMgr.cc
index b0f78ae4..37c8b439 100644
--- a/dev/kernel/src/DriveMgr.cc
+++ b/dev/kernel/src/DriveMgr.cc
@@ -31,9 +31,11 @@ STATIC UInt16 kAHCIPortsImplemented [[maybe_unused]] = 0UL;
 /// @brief reads from an ATA drive.
 /// @param pckt Packet structure (fPacketContent must be non null)
 /// @return
-Void io_drv_input(DriveTrait::DrivePacket pckt) {
+Void io_drv_input(DriveTrait::DrivePacket& pckt) {
 #ifdef __AHCI__
   drv_std_read(pckt.fPacketLba, (Char*) pckt.fPacketContent, kAHCISectorSize, pckt.fPacketSize);
+
+  if (err_global_get() != kErrorSuccess) pckt.fPacketGood = NO;
 #elif defined(__ATA_PIO__) || defined(__ATA_DMA__)
   drv_std_read(pckt.fPacketLba, kATAIO, kATAMaster, (Char*) pckt.fPacketContent, kATASectorSize,
                pckt.fPacketSize);
@@ -43,7 +45,7 @@ Void io_drv_input(DriveTrait::DrivePacket pckt) {
 /// @brief Writes to an ATA drive.
 /// @param pckt the packet to write.
 /// @return
-Void io_drv_output(DriveTrait::DrivePacket pckt) {
+Void io_drv_output(DriveTrait::DrivePacket& pckt) {
   if (pckt.fPacketReadOnly) {
     pckt.fPacketGood = NO;
     return;
@@ -51,6 +53,8 @@ Void io_drv_output(DriveTrait::DrivePacket pckt) {
 
 #ifdef __AHCI__
   drv_std_write(pckt.fPacketLba, (Char*) pckt.fPacketContent, kAHCISectorSize, pckt.fPacketSize);
+
+  if (err_global_get() != kErrorSuccess) pckt.fPacketGood = NO;
 #elif defined(__ATA_PIO__) || defined(__ATA_DMA__)
   drv_std_write(pckt.fPacketLba, kATAIO, kATAMaster, (Char*) pckt.fPacketContent, kATASectorSize,
                 pckt.fPacketSize);
@@ -60,7 +64,7 @@ Void io_drv_output(DriveTrait::DrivePacket pckt) {
 /// @brief Executes a disk check on the ATA drive.
 /// @param pckt the packet to read.
 /// @return
-Void io_drv_init(DriveTrait::DrivePacket pckt) {
+Void io_drv_init(DriveTrait::DrivePacket& pckt) {
   NE_UNUSED(pckt);
 
 #if defined(__ATA_PIO__) || defined(__ATA_DMA__)
@@ -116,7 +120,7 @@ const Char* io_drv_kind(Void) {
 
 /// @brief Unimplemented drive function.
 /// @param pckt the packet to read.
-Void io_drv_unimplemented(DriveTrait::DrivePacket pckt) noexcept {
+Void io_drv_unimplemented(DriveTrait::DrivePacket& pckt) noexcept {
   NE_UNUSED(pckt);
 }
 
diff --git a/dev/kernel/src/FS/HeFS.cc b/dev/kernel/src/FS/HeFS.cc
index 47248d4c..6809f4b4 100644
--- a/dev/kernel/src/FS/HeFS.cc
+++ b/dev/kernel/src/FS/HeFS.cc
@@ -4,6 +4,7 @@
 
 ------------------------------------------- */
 
+#include "NewKit/Macros.h"
 #ifdef __FSKIT_INCLUDES_HEFS__
 
 #include <FSKit/HeFS.h>
@@ -29,7 +30,7 @@ namespace Detail {
   /// @note This function is used to traverse the RB-Tree of the filesystem.
   /// @internal Internal filesystem use only.
   STATIC ATTRIBUTE(unused) _Output Void
-      hefsi_traverse_tree(HEFS_INDEX_NODE_DIRECTORY dir, Lba& start);
+      hefsi_traverse_tree(HEFS_INDEX_NODE_DIRECTORY* dir, Lba& start, Bool hop_watch = NO);
 
   /// @brief Get the index node of a file or directory.
   /// @param root The root node of the filesystem.
@@ -39,7 +40,7 @@ namespace Detail {
   /// @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_index_node(
-      HEFS_BOOT_NODE root, DriveTrait* mnt, const Utf8Char* dir_name, const Utf8Char* file_name,
+      HEFS_BOOT_NODE* root, DriveTrait* mnt, const Utf8Char* dir_name, const Utf8Char* file_name,
       UInt8 kind, SizeT* cnt) noexcept;
 
   /// @brief Get the index node size.
@@ -50,24 +51,24 @@ namespace Detail {
   /// @param kind The kind of the file (regular, directory, block, character, FIFO, socket, symbolic
   /// link, unknown).
   STATIC ATTRIBUTE(unused) _Output SizeT
-      hefsi_fetch_index_node_size(HEFS_BOOT_NODE root, DriveTrait* mnt, const Utf8Char* dir_name,
+      hefsi_fetch_index_node_size(HEFS_BOOT_NODE* root, DriveTrait* mnt, const Utf8Char* dir_name,
                                   const Utf8Char* file_name, UInt8 kind) noexcept;
 
-  /// @brief Allocate a new index node.
+  /// @brief Allocate a new index node->
   /// @param root The root node of the filesystem.
   /// @param mnt The drive to read/write from.
   /// @param parent_dir_name The name of the parent directory.
   /// @return Status, see err_global_get().
   STATIC ATTRIBUTE(unused) _Output BOOL
-      hefsi_allocate_index_node(HEFS_BOOT_NODE root, DriveTrait* mnt,
-                                const Utf8Char* parent_dir_name, HEFS_INDEX_NODE node) noexcept;
+      hefsi_allocate_index_node(HEFS_BOOT_NODE* root, DriveTrait* mnt,
+                                const Utf8Char* parent_dir_name, HEFS_INDEX_NODE* node) noexcept;
 
   /// @brief Balance RB-Tree of the filesystem.
   /// @param root The root node of the filesystem.
   /// @param mnt The drive to read/write from.
   /// @return Status, see err_global_get().
   STATIC ATTRIBUTE(unused) _Output BOOL
-      hefsi_balance_filesystem(HEFS_BOOT_NODE root, DriveTrait* mnt);
+      hefsi_balance_filesystem(HEFS_BOOT_NODE* root, DriveTrait* mnt);
 
   /// @brief Traverse the RB-Tree of the filesystem.
   /// @param dir The directory to traverse.
@@ -75,16 +76,20 @@ namespace Detail {
   /// @note This function is used to traverse the RB-Tree of the filesystem.
   /// @internal Internal filesystem use only.
   STATIC ATTRIBUTE(unused) _Output Void
-      hefsi_traverse_tree(HEFS_INDEX_NODE_DIRECTORY dir, Lba& start) {
-    if (dir.fChild != 0) {
-      start = dir.fChild;
-    } else if (dir.fNext != 0) {
-      start = dir.fNext;
-    } else if (dir.fParent != 0) {
-      start = dir.fParent;
-    } else if (dir.fPrev != 0) {
-      start = dir.fPrev;
+      hefsi_traverse_tree(HEFS_INDEX_NODE_DIRECTORY* dir, Lba& start, Bool hop_watch) {
+    if (dir->fChild != 0) {
+      start = dir->fChild;
+    } else if (dir->fNext != 0) {
+      start = dir->fNext;
+    } else if (dir->fParent != 0) {
+      start = dir->fParent;
+    } else if (dir->fPrev != 0) {
+      start = dir->fPrev;
     } else {
+      if (hop_watch) {
+        err_global_get() = kErrorDisk;
+      }
+
       start += kHeFSINDStartOffset;
     }
 
@@ -96,37 +101,41 @@ namespace Detail {
   /// @internal
   /***********************************************************************************/
   STATIC ATTRIBUTE(unused) _Output Void
-      hefsi_rotate_left(HEFS_INDEX_NODE_DIRECTORY dir, Lba& start, DriveTrait* mnt) {
-    HEFS_INDEX_NODE_DIRECTORY parent;
+      hefsi_rotate_left(HEFS_INDEX_NODE_DIRECTORY* dir, Lba& start, DriveTrait* mnt) {
+    HEFS_INDEX_NODE_DIRECTORY* parent =
+        (HEFS_INDEX_NODE_DIRECTORY*) RTL_ALLOCA(sizeof(HEFS_INDEX_NODE_DIRECTORY));
 
-    mnt->fPacket.fPacketLba     = dir.fParent;
+    mnt->fPacket.fPacketLba     = dir->fParent;
     mnt->fPacket.fPacketSize    = sizeof(HEFS_INDEX_NODE_DIRECTORY);
-    mnt->fPacket.fPacketContent = &parent;
+    mnt->fPacket.fPacketContent = parent;
 
     mnt->fInput(mnt->fPacket);
 
-    HEFS_INDEX_NODE_DIRECTORY grand_parent;
+    HEFS_INDEX_NODE_DIRECTORY* grand_parent =
+        (HEFS_INDEX_NODE_DIRECTORY*) RTL_ALLOCA(sizeof(HEFS_INDEX_NODE_DIRECTORY));
 
-    mnt->fPacket.fPacketLba     = parent.fParent;
+    mnt->fPacket.fPacketLba     = parent->fParent;
     mnt->fPacket.fPacketSize    = sizeof(HEFS_INDEX_NODE_DIRECTORY);
-    mnt->fPacket.fPacketContent = &grand_parent;
+    mnt->fPacket.fPacketContent = grand_parent;
 
     mnt->fInput(mnt->fPacket);
 
-    dir.fParent    = parent.fParent;
-    parent.fParent = start;
-    parent.fNext   = dir.fChild;
-    dir.fChild     = dir.fParent;
+    dir->fParent    = parent->fParent;
+    parent->fParent = start;
+    parent->fNext   = dir->fChild;
+    dir->fChild     = dir->fParent;
 
-    mnt->fPacket.fPacketLba     = parent.fParent;
+    if (parent->fParent == 0 || dir->fParent == 0) return;
+
+    mnt->fPacket.fPacketLba     = parent->fParent;
     mnt->fPacket.fPacketSize    = sizeof(HEFS_INDEX_NODE_DIRECTORY);
-    mnt->fPacket.fPacketContent = &grand_parent;
+    mnt->fPacket.fPacketContent = grand_parent;
 
     mnt->fOutput(mnt->fPacket);
 
-    mnt->fPacket.fPacketLba     = dir.fParent;
+    mnt->fPacket.fPacketLba     = dir->fParent;
     mnt->fPacket.fPacketSize    = sizeof(HEFS_INDEX_NODE_DIRECTORY);
-    mnt->fPacket.fPacketContent = &parent;
+    mnt->fPacket.fPacketContent = parent;
 
     mnt->fOutput(mnt->fPacket);
 
@@ -138,31 +147,32 @@ namespace Detail {
   /// @internal
   /***********************************************************************************/
   STATIC ATTRIBUTE(unused) _Output Void
-      hefsi_rotate_right(HEFS_INDEX_NODE_DIRECTORY dir, Lba& start, DriveTrait* mnt) {
-    HEFS_INDEX_NODE_DIRECTORY parent;
+      hefsi_rotate_right(HEFS_INDEX_NODE_DIRECTORY* dir, Lba& start, DriveTrait* mnt) {
+    HEFS_INDEX_NODE_DIRECTORY* parent =
+        (HEFS_INDEX_NODE_DIRECTORY*) RTL_ALLOCA(sizeof(HEFS_INDEX_NODE_DIRECTORY));
 
-    mnt->fPacket.fPacketLba     = dir.fParent;
+    mnt->fPacket.fPacketLba     = dir->fParent;
     mnt->fPacket.fPacketSize    = sizeof(HEFS_INDEX_NODE_DIRECTORY);
-    mnt->fPacket.fPacketContent = &parent;
+    mnt->fPacket.fPacketContent = parent;
 
     mnt->fInput(mnt->fPacket);
 
-    parent.fParent = dir.fParent;
-    dir.fParent    = parent.fParent;
-    dir.fNext      = parent.fChild;
-    parent.fChild  = start;
+    parent->fParent = dir->fParent;
+    dir->fParent    = parent->fParent;
+    dir->fNext      = parent->fChild;
+    parent->fChild  = start;
 
-    mnt->fPacket.fPacketLba     = dir.fParent;
+    mnt->fPacket.fPacketLba     = dir->fParent;
     mnt->fPacket.fPacketSize    = sizeof(HEFS_INDEX_NODE_DIRECTORY);
-    mnt->fPacket.fPacketContent = &parent;
+    mnt->fPacket.fPacketContent = parent;
 
     mnt->fOutput(mnt->fPacket);
 
-    dir.fColor = kHeFSBlack;
+    dir->fColor = kHeFSBlack;
 
     mnt->fPacket.fPacketLba     = start;
     mnt->fPacket.fPacketSize    = sizeof(HEFS_INDEX_NODE_DIRECTORY);
-    mnt->fPacket.fPacketContent = &dir;
+    mnt->fPacket.fPacketContent = dir;
 
     mnt->fOutput(mnt->fPacket);
 
@@ -177,20 +187,21 @@ namespace Detail {
   /// @param kind The kind of the file (regular, directory, block, character, FIFO, socket, symbolic
   /// link, unknown).
   STATIC ATTRIBUTE(unused) _Output SizeT
-      hefsi_fetch_index_node_size(HEFS_BOOT_NODE root, DriveTrait* mnt, const Utf8Char* dir_name,
+      hefsi_fetch_index_node_size(HEFS_BOOT_NODE* root, DriveTrait* mnt, const Utf8Char* dir_name,
                                   const Utf8Char* file_name, UInt8 kind) noexcept {
     if (mnt) {
-      HEFS_INDEX_NODE           node;
-      HEFS_INDEX_NODE_DIRECTORY dir;
+      HEFS_INDEX_NODE*           node = (HEFS_INDEX_NODE*) RTL_ALLOCA(sizeof(HEFS_INDEX_NODE));
+      HEFS_INDEX_NODE_DIRECTORY* dir =
+          (HEFS_INDEX_NODE_DIRECTORY*) RTL_ALLOCA(sizeof(HEFS_INDEX_NODE_DIRECTORY));
 
       SizeT sz = 0UL;
 
-      auto start = root.fStartIND;
+      auto start = root->fStartIND;
 
       while (YES) {
         mnt->fPacket.fPacketLba     = start;
         mnt->fPacket.fPacketSize    = sizeof(HEFS_INDEX_NODE_DIRECTORY);
-        mnt->fPacket.fPacketContent = &dir;
+        mnt->fPacket.fPacketContent = dir;
 
         mnt->fInput(mnt->fPacket);
 
@@ -200,20 +211,20 @@ namespace Detail {
           return 0;
         }
 
-        if (dir.fKind == kHeFSFileKindDirectory) {
-          if (KStringBuilder::Equals(dir_name, dir.fName) ||
+        if (dir->fKind == kHeFSFileKindDirectory) {
+          if (KStringBuilder::Equals(dir_name, dir->fName) ||
               KStringBuilder::Equals(dir_name, kHeFSSearchAllStr)) {
             for (SizeT inode_index = 0UL; inode_index < kHeFSBlockCount; inode_index += 2) {
-              mnt->fPacket.fPacketLba     = dir.fIndexNode[inode_index];
+              mnt->fPacket.fPacketLba     = dir->fIndexNode[inode_index];
               mnt->fPacket.fPacketSize    = sizeof(HEFS_INDEX_NODE);
-              mnt->fPacket.fPacketContent = &node;
+              mnt->fPacket.fPacketContent = node;
               mnt->fInput(mnt->fPacket);
 
-              if (KStringBuilder::Equals(file_name, node.fName) && node.fKind == kind) {
-                if (node.fKind == kHeFSFileKindDirectory) {
+              if (KStringBuilder::Equals(file_name, node->fName) && node->fKind == kind) {
+                if (node->fKind == kHeFSFileKindDirectory) {
                   sz += hefsi_fetch_index_node_size(root, mnt, dir_name, file_name, kind);
                 } else {
-                  sz = node.fSize;
+                  sz = node->fSize;
                 }
 
                 return sz;
@@ -231,18 +242,27 @@ namespace Detail {
     return 0;
   }
 
-  STATIC _Output BOOL hefsi_allocate_index_directory_node(HEFS_BOOT_NODE root, DriveTrait* mnt,
+  /// @brief Alllocate IND for boot node->
+  STATIC _Output BOOL hefsi_allocate_index_directory_node(HEFS_BOOT_NODE* root, DriveTrait* mnt,
                                                           const Utf8Char* dir_name,
                                                           UInt16          flags) noexcept {
+    if (urt_string_len(dir_name) >= kHeFSFileNameLen) {
+      err_global_get() = kErrorDisk;
+      return NO;
+    }
+
     if (mnt) {
-      HEFS_INDEX_NODE_DIRECTORY tmpdir;
+      HEFS_INDEX_NODE_DIRECTORY* tmpdir =
+          (HEFS_INDEX_NODE_DIRECTORY*) RTL_ALLOCA(sizeof(HEFS_INDEX_NODE_DIRECTORY));
 
-      auto start = root.fStartIND;
+      auto start = root->fStartIND;
 
       while (YES) {
+        if (start == 0) break;
+
         mnt->fPacket.fPacketLba     = start;
         mnt->fPacket.fPacketSize    = sizeof(HEFS_INDEX_NODE_DIRECTORY);
-        mnt->fPacket.fPacketContent = &tmpdir;
+        mnt->fPacket.fPacketContent = tmpdir;
 
         mnt->fInput(mnt->fPacket);
 
@@ -250,91 +270,95 @@ namespace Detail {
           break;
         }
 
-        if ((!tmpdir.fCreated && tmpdir.fDeleted) || *tmpdir.fName == 0) {
-          HEFS_INDEX_NODE_DIRECTORY dirent;
+        if ((!tmpdir->fCreated && tmpdir->fDeleted) || *tmpdir->fName == 0) {
+          HEFS_INDEX_NODE_DIRECTORY* dirent =
+              (HEFS_INDEX_NODE_DIRECTORY*) mm_new_heap(sizeof(HEFS_INDEX_NODE_DIRECTORY), Yes, No);
 
-          urt_copy_memory((VoidPtr) dir_name, dirent.fName, urt_string_len(dir_name));
+          urt_copy_memory((VoidPtr) dir_name, dirent->fName, urt_string_len(dir_name) + 1);
 
-          dirent.fAccessed   = 0;
-          dirent.fCreated    = 1UL;
-          dirent.fDeleted    = 0;
-          dirent.fModified   = 0;
-          dirent.fEntryCount = 0;
+          dirent->fAccessed   = 0;
+          dirent->fCreated    = 1UL;
+          dirent->fDeleted    = 0;
+          dirent->fModified   = 0;
+          dirent->fEntryCount = 0;
 
-          dirent.fKind     = kHeFSFileKindDirectory;
-          dirent.fFlags    = flags;
-          dirent.fChecksum = 0;
+          dirent->fKind     = kHeFSFileKindDirectory;
+          dirent->fFlags    = flags;
+          dirent->fChecksum = 0;
 
-          dirent.fChecksum = ke_calculate_crc32((Char*) &dirent, sizeof(HEFS_INDEX_NODE_DIRECTORY));
+          dirent->fChecksum = ke_calculate_crc32((Char*) dirent, sizeof(HEFS_INDEX_NODE_DIRECTORY));
 
-          dirent.fEntryCount = 0;
+          dirent->fEntryCount = 0;
 
-          dirent.fNext = tmpdir.fNext;
-          dirent.fPrev = tmpdir.fPrev;
+          dirent->fNext = tmpdir->fNext;
+          dirent->fPrev = tmpdir->fPrev;
 
-          if (dirent.fPrev == 0) {
-            dirent.fPrev = root.fStartIND;
+          if (dirent->fPrev == 0) {
+            dirent->fPrev = root->fStartIND;
           }
 
-          if (dirent.fNext == 0) {
-            if (start < root.fEndIND) {
-              dirent.fNext = start + sizeof(HEFS_INDEX_NODE_DIRECTORY);
+          if (dirent->fNext == 0) {
+            if (start < root->fEndIND) {
+              dirent->fNext = start + sizeof(HEFS_INDEX_NODE_DIRECTORY);
             } else {
-              dirent.fNext = 0;
+              dirent->fNext = 0;
             }
           }
 
-          if (tmpdir.fParent == 0) {
-            tmpdir.fParent = root.fStartIND;
+          if (tmpdir->fParent == 0) {
+            tmpdir->fParent = root->fStartIND;
           }
 
-          if (tmpdir.fChild == 0) {
-            auto child = root.fEndIND;
+          if (tmpdir->fChild == 0) {
+            auto child = root->fEndIND;
 
-            HEFS_INDEX_NODE_DIRECTORY tmpend;
+            HEFS_INDEX_NODE_DIRECTORY* tmpend =
+                (HEFS_INDEX_NODE_DIRECTORY*) RTL_ALLOCA(sizeof(HEFS_INDEX_NODE_DIRECTORY));
 
             while (YES) {
               mnt->fPacket.fPacketLba     = child;
               mnt->fPacket.fPacketSize    = sizeof(HEFS_INDEX_NODE_DIRECTORY);
-              mnt->fPacket.fPacketContent = &tmpend;
+              mnt->fPacket.fPacketContent = tmpend;
 
               mnt->fInput(mnt->fPacket);
 
-              if ((!tmpend.fCreated && tmpend.fDeleted) || *tmpend.fName == 0) {
+              if ((!tmpend->fCreated && tmpend->fDeleted) || *tmpend->fName == 0) {
                 break;
               }
 
               child -= sizeof(HEFS_INDEX_NODE_DIRECTORY);
-              if (child < root.fStartIND || child > root.fEndIND) break;
+              if (child < root->fStartIND || child > root->fEndIND) break;
             }
 
-            dirent.fColor = kHeFSRed;
-            dirent.fChild = child;
+            dirent->fColor = kHeFSRed;
+            dirent->fChild = child;
 
-            if (child > root.fEndIND) dirent.fChild = root.fEndIND;
+            if (child > root->fEndIND) dirent->fChild = root->fEndIND;
           } else {
-            dirent.fColor = tmpdir.fColor;
-            dirent.fChild = tmpdir.fChild;
+            dirent->fColor = tmpdir->fColor;
+            dirent->fChild = tmpdir->fChild;
           }
 
           for (SizeT index = 0UL; index < (kHeFSBlockCount * 2); index += 2) {
-            dirent.fIndexNode[index]     = root.fStartIN;
-            dirent.fIndexNode[index + 1] = 0UL;
+            dirent->fIndexNode[index]     = root->fStartIN;
+            dirent->fIndexNode[index + 1] = 0UL;
           }
 
           mnt->fPacket.fPacketLba     = start;
           mnt->fPacket.fPacketSize    = sizeof(HEFS_INDEX_NODE_DIRECTORY);
-          mnt->fPacket.fPacketContent = &dirent;
+          mnt->fPacket.fPacketContent = dirent;
 
           mnt->fOutput(mnt->fPacket);
 
           err_global_get() = kErrorSuccess;
 
+          mm_delete_heap(dirent);
+
           return YES;
         }
 
         hefsi_traverse_tree(tmpdir, start);
-        if (start > root.fEndIND) break;
+        if (start > root->fEndIND || start == 0) break;
       }
 
       err_global_get() = kErrorDisk;
@@ -346,17 +370,18 @@ namespace Detail {
     return NO;
   }
 
-  STATIC _Output HEFS_INDEX_NODE_DIRECTORY
-  hefsi_fetch_index_node_directory(HEFS_BOOT_NODE root, DriveTrait* mnt, const Utf8Char* dir_name) {
+  STATIC _Output HEFS_INDEX_NODE_DIRECTORY* hefsi_fetch_index_node_directory(
+      HEFS_BOOT_NODE* root, DriveTrait* mnt, const Utf8Char* dir_name) {
     if (mnt) {
-      HEFS_INDEX_NODE_DIRECTORY dir;
+      HEFS_INDEX_NODE_DIRECTORY* dir =
+          (HEFS_INDEX_NODE_DIRECTORY*) RTL_ALLOCA(sizeof(HEFS_INDEX_NODE_DIRECTORY));
 
-      auto start = root.fStartIND;
+      auto start = root->fStartIND;
 
       while (YES) {
         mnt->fPacket.fPacketLba     = start;
         mnt->fPacket.fPacketSize    = sizeof(HEFS_INDEX_NODE_DIRECTORY);
-        mnt->fPacket.fPacketContent = &dir;
+        mnt->fPacket.fPacketContent = dir;
 
         mnt->fInput(mnt->fPacket);
 
@@ -366,10 +391,10 @@ namespace Detail {
           return {};
         }
 
-        if (dir.fKind == kHeFSFileKindDirectory) {
-          if (KStringBuilder::Equals(dir_name, dir.fName)) {
+        if (dir->fKind == kHeFSFileKindDirectory) {
+          if (KStringBuilder::Equals(dir_name, dir->fName)) {
             if (ke_calculate_crc32((Char*) &dir, sizeof(HEFS_INDEX_NODE_DIRECTORY)) !=
-                dir.fChecksum)
+                dir->fChecksum)
               ke_panic(RUNTIME_CHECK_FILESYSTEM, "CRC32 failure on HeFS IND!");
 
             err_global_get() = kErrorSuccess;
@@ -378,7 +403,7 @@ namespace Detail {
         }
 
         hefsi_traverse_tree(dir, start);
-        if (start > root.fEndIND) break;
+        if (start > root->fEndIND || start == 0) break;
       }
     }
 
@@ -394,7 +419,7 @@ namespace Detail {
   /// @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_index_node(
-      HEFS_BOOT_NODE root, DriveTrait* mnt, const Utf8Char* dir_name, const Utf8Char* file_name,
+      HEFS_BOOT_NODE* root, DriveTrait* mnt, const Utf8Char* dir_name, const Utf8Char* file_name,
       UInt8 kind, SizeT* cnt) noexcept {
     if (mnt) {
       HEFS_INDEX_NODE* node_arr = new HEFS_INDEX_NODE[*cnt];
@@ -403,17 +428,18 @@ namespace Detail {
         return nullptr;
       }
 
-      HEFS_INDEX_NODE           node;
-      HEFS_INDEX_NODE_DIRECTORY dir;
+      HEFS_INDEX_NODE*           node = (HEFS_INDEX_NODE*) RTL_ALLOCA(sizeof(HEFS_INDEX_NODE));
+      HEFS_INDEX_NODE_DIRECTORY* dir =
+          (HEFS_INDEX_NODE_DIRECTORY*) RTL_ALLOCA(sizeof(HEFS_INDEX_NODE_DIRECTORY));
 
-      auto start = root.fStartIND;
+      auto start = root->fStartIND;
 
       auto start_cnt = 0UL;
 
       while (YES) {
         mnt->fPacket.fPacketLba     = start;
         mnt->fPacket.fPacketSize    = sizeof(HEFS_INDEX_NODE_DIRECTORY);
-        mnt->fPacket.fPacketContent = &dir;
+        mnt->fPacket.fPacketContent = dir;
 
         mnt->fInput(mnt->fPacket);
 
@@ -424,27 +450,27 @@ namespace Detail {
           return nullptr;
         }
 
-        if (dir.fKind == kHeFSFileKindDirectory) {
-          if (KStringBuilder::Equals(dir_name, dir.fName) ||
+        if (dir->fKind == kHeFSFileKindDirectory) {
+          if (KStringBuilder::Equals(dir_name, dir->fName) ||
               KStringBuilder::Equals(dir_name, kHeFSSearchAllStr)) {
             if (ke_calculate_crc32((Char*) &dir, sizeof(HEFS_INDEX_NODE_DIRECTORY)) !=
-                dir.fChecksum)
+                dir->fChecksum)
               ke_panic(RUNTIME_CHECK_FILESYSTEM, "CRC32 failure on HeFS IND!");
 
             for (SizeT inode_index = 0UL; inode_index < (kHeFSBlockCount * 2); inode_index += 2) {
-              if (dir.fIndexNode[inode_index] != 0) {
-                mnt->fPacket.fPacketLba     = dir.fIndexNode[inode_index];
+              if (dir->fIndexNode[inode_index] != 0) {
+                mnt->fPacket.fPacketLba     = dir->fIndexNode[inode_index];
                 mnt->fPacket.fPacketSize    = sizeof(HEFS_INDEX_NODE);
-                mnt->fPacket.fPacketContent = &node;
+                mnt->fPacket.fPacketContent = node;
 
                 mnt->fInput(mnt->fPacket);
 
                 if (mnt->fPacket.fPacketGood) {
-                  if (ke_calculate_crc32((Char*) &node, sizeof(HEFS_INDEX_NODE)) != node.fChecksum)
+                  if (ke_calculate_crc32((Char*) &node, sizeof(HEFS_INDEX_NODE)) != node->fChecksum)
                     ke_panic(RUNTIME_CHECK_FILESYSTEM, "CRC32 failure on HeFS IND!");
 
-                  if (KStringBuilder::Equals(file_name, node.fName) && node.fKind == kind) {
-                    node_arr[start_cnt] = node;
+                  if (KStringBuilder::Equals(file_name, node->fName) && node->fKind == kind) {
+                    node_arr[start_cnt] = *node;
                     ++start_cnt;
 
                     if (start_cnt > *cnt) {
@@ -466,45 +492,46 @@ namespace Detail {
         }
 
         hefsi_traverse_tree(dir, start);
-        if (start > root.fEndIND) break;
+        if (start > root->fEndIND || start == 0) break;
       }
     }
 
-    kout << "Error: Failed to find index node.\r";
+    kout << "Error: Failed to find index node->\r";
 
     err_global_get() = kErrorFileNotFound;
 
     return nullptr;
   }
 
-  /// @brief Allocate a new index node.
+  /// @brief Allocate a new index node->
   /// @param root The root node of the filesystem.
   /// @param mnt The drive to read from.
   /// @param parent_dir_name The name of the parent directory.
   /// @return Status, see err_global_get().
   STATIC ATTRIBUTE(unused) _Output BOOL
-      hefsi_allocate_index_node(HEFS_BOOT_NODE root, DriveTrait* mnt,
-                                const Utf8Char* parent_dir_name, HEFS_INDEX_NODE node) noexcept {
+      hefsi_allocate_index_node(HEFS_BOOT_NODE* root, DriveTrait* mnt,
+                                const Utf8Char* parent_dir_name, HEFS_INDEX_NODE* node) noexcept {
     if (mnt) {
-      HEFS_INDEX_NODE_DIRECTORY dir;
+      HEFS_INDEX_NODE_DIRECTORY* dir =
+          (HEFS_INDEX_NODE_DIRECTORY*) RTL_ALLOCA(sizeof(HEFS_INDEX_NODE_DIRECTORY));
 
-      auto start = root.fStartIND;
+      auto start = root->fStartIND;
 
       while (YES) {
         mnt->fPacket.fPacketLba     = start;
         mnt->fPacket.fPacketSize    = sizeof(HEFS_INDEX_NODE_DIRECTORY);
-        mnt->fPacket.fPacketContent = &dir;
+        mnt->fPacket.fPacketContent = dir;
 
         mnt->fInput(mnt->fPacket);
 
-        if (KStringBuilder::Equals(dir.fName, parent_dir_name)) {
+        if (KStringBuilder::Equals(dir->fName, parent_dir_name)) {
           for (SizeT inode_index = 0UL; inode_index < (kHeFSBlockCount * 2); inode_index += 2) {
-            if (dir.fIndexNode[inode_index] != 0) {
-              auto lba = dir.fIndexNode[inode_index];
+            if (dir->fIndexNode[inode_index] != 0) {
+              auto lba = dir->fIndexNode[inode_index];
 
               mnt->fPacket.fPacketLba     = lba;
               mnt->fPacket.fPacketSize    = sizeof(HEFS_INDEX_NODE);
-              mnt->fPacket.fPacketContent = &node;
+              mnt->fPacket.fPacketContent = node;
 
               mnt->fOutput(mnt->fPacket);
 
@@ -516,7 +543,7 @@ namespace Detail {
         }
 
         hefsi_traverse_tree(dir, start);
-        if (start > root.fEndIND) break;
+        if (start > root->fEndIND || start == 0) break;
       }
 
       return YES;
@@ -530,17 +557,21 @@ namespace Detail {
   /// @param mnt The drive to read/write from.
   /// @return Status, see err_global_get().
   STATIC ATTRIBUTE(unused) _Output BOOL
-      hefsi_balance_filesystem(HEFS_BOOT_NODE root, DriveTrait* mnt) {
+      hefsi_balance_filesystem(HEFS_BOOT_NODE* root, DriveTrait* mnt) {
     if (mnt) {
-      HEFS_INDEX_NODE_DIRECTORY dir;
-      HEFS_INDEX_NODE_DIRECTORY dir_parent;
+      HEFS_INDEX_NODE_DIRECTORY* dir =
+          (HEFS_INDEX_NODE_DIRECTORY*) RTL_ALLOCA(sizeof(HEFS_INDEX_NODE_DIRECTORY));
+      HEFS_INDEX_NODE_DIRECTORY* dir_parent =
+          (HEFS_INDEX_NODE_DIRECTORY*) RTL_ALLOCA(sizeof(HEFS_INDEX_NODE_DIRECTORY));
 
-      auto start = root.fStartIND;
+      auto start = root->fStartIND;
 
       while (YES) {
+        if (start == 0) break;
+
         mnt->fPacket.fPacketLba     = start;
         mnt->fPacket.fPacketSize    = sizeof(HEFS_INDEX_NODE_DIRECTORY);
-        mnt->fPacket.fPacketContent = &dir;
+        mnt->fPacket.fPacketContent = dir;
 
         mnt->fInput(mnt->fPacket);
 
@@ -550,19 +581,19 @@ namespace Detail {
           return NO;
         }
 
-        if (start == root.fStartIND) {
-          dir.fColor = kHeFSBlack;
+        if (start == root->fStartIND) {
+          dir->fColor = kHeFSBlack;
 
           mnt->fPacket.fPacketLba     = start;
           mnt->fPacket.fPacketSize    = sizeof(HEFS_INDEX_NODE_DIRECTORY);
-          mnt->fPacket.fPacketContent = &dir;
+          mnt->fPacket.fPacketContent = dir;
 
           mnt->fOutput(mnt->fPacket);
         }
 
-        mnt->fPacket.fPacketLba     = dir.fParent;
+        mnt->fPacket.fPacketLba     = dir->fParent;
         mnt->fPacket.fPacketSize    = sizeof(HEFS_INDEX_NODE_DIRECTORY);
-        mnt->fPacket.fPacketContent = &dir_parent;
+        mnt->fPacket.fPacketContent = dir_parent;
 
         mnt->fInput(mnt->fPacket);
 
@@ -572,11 +603,12 @@ namespace Detail {
           return NO;
         }
 
-        HEFS_INDEX_NODE_DIRECTORY dir_uncle;
+        HEFS_INDEX_NODE_DIRECTORY* dir_uncle =
+            (HEFS_INDEX_NODE_DIRECTORY*) RTL_ALLOCA(sizeof(HEFS_INDEX_NODE_DIRECTORY));
 
-        mnt->fPacket.fPacketLba     = dir_parent.fNext;
+        mnt->fPacket.fPacketLba     = dir_parent->fNext;
         mnt->fPacket.fPacketSize    = sizeof(HEFS_INDEX_NODE_DIRECTORY);
-        mnt->fPacket.fPacketContent = &dir_uncle;
+        mnt->fPacket.fPacketContent = dir_uncle;
 
         mnt->fInput(mnt->fPacket);
 
@@ -586,19 +618,19 @@ namespace Detail {
           return NO;
         }
 
-        if (dir_uncle.fColor == kHeFSRed) {
-          dir_parent.fColor = kHeFSBlack;
-          dir_uncle.fColor  = kHeFSBlack;
+        if (dir_uncle->fColor == kHeFSRed) {
+          dir_parent->fColor = kHeFSBlack;
+          dir_uncle->fColor  = kHeFSBlack;
 
-          mnt->fPacket.fPacketLba     = dir.fParent;
+          mnt->fPacket.fPacketLba     = dir->fParent;
           mnt->fPacket.fPacketSize    = sizeof(HEFS_INDEX_NODE_DIRECTORY);
-          mnt->fPacket.fPacketContent = &dir_parent;
+          mnt->fPacket.fPacketContent = dir_parent;
 
           mnt->fOutput(mnt->fPacket);
 
-          mnt->fPacket.fPacketLba     = dir_uncle.fParent;
+          mnt->fPacket.fPacketLba     = dir_uncle->fParent;
           mnt->fPacket.fPacketSize    = sizeof(HEFS_INDEX_NODE_DIRECTORY);
-          mnt->fPacket.fPacketContent = &dir_uncle;
+          mnt->fPacket.fPacketContent = dir_uncle;
 
           mnt->fOutput(mnt->fPacket);
 
@@ -608,26 +640,26 @@ namespace Detail {
             return NO;
           }
 
-          hefsi_traverse_tree(dir, start);
+          hefsi_traverse_tree(dir, start, YES);
 
-          if (start > root.fEndIND) break;
+          if (start > root->fEndIND || start == 0) break;
 
           continue;
         } else {
-          if (dir_parent.fNext == start) {
+          if (dir_parent->fNext == start) {
             hefsi_rotate_left(dir_parent, start, mnt);
-            hefsi_traverse_tree(dir_parent, start);
+            hefsi_traverse_tree(dir_parent, start, YES);
 
-            if (start > root.fEndIND) break;
+            if (start > root->fEndIND || start == 0) break;
 
             continue;
           }
 
-          dir_parent.fColor = kHeFSBlack;
+          dir_parent->fColor = kHeFSBlack;
 
-          mnt->fPacket.fPacketLba     = dir.fParent;
+          mnt->fPacket.fPacketLba     = dir->fParent;
           mnt->fPacket.fPacketSize    = sizeof(HEFS_INDEX_NODE_DIRECTORY);
-          mnt->fPacket.fPacketContent = &dir_parent;
+          mnt->fPacket.fPacketContent = dir_parent;
 
           mnt->fOutput(mnt->fPacket);
 
@@ -640,8 +672,8 @@ namespace Detail {
           hefsi_rotate_right(dir, start, mnt);
         }
 
-        hefsi_traverse_tree(dir, start);
-        if (start > root.fEndIND) break;
+        hefsi_traverse_tree(dir, start, YES);
+        if (start > root->fEndIND || start == 0) break;
       }
 
       return YES;
@@ -677,15 +709,15 @@ _Output Bool HeFileSystemParser::Format(_Input _Output DriveTrait* drive, _Input
 
   if (drv_std_get_size() < kHeFSMinimumDiskSize) {
     err_global_get() = kErrorDiskIsTooTiny;
-    kout << "Error: Failed to allocate memory for boot node.\r";
+    kout << "Error: Failed to allocate memory for boot node->\r";
     return NO;
   }
 
-  HEFS_BOOT_NODE root;
+  HEFS_BOOT_NODE* root = (HEFS_BOOT_NODE*) RTL_ALLOCA(sizeof(HEFS_BOOT_NODE));
 
   drive->fPacket.fPacketLba     = drive->fLbaStart;
   drive->fPacket.fPacketSize    = sizeof(HEFS_BOOT_NODE);
-  drive->fPacket.fPacketContent = &root;
+  drive->fPacket.fPacketContent = root;
 
   drive->fInput(drive->fPacket);
 
@@ -697,7 +729,7 @@ _Output Bool HeFileSystemParser::Format(_Input _Output DriveTrait* drive, _Input
 
   // Check if the disk is already formatted.
 
-  if (KStringBuilder::Equals(root.fMagic, kHeFSMagic) && root.fVersion == kHeFSVersion) {
+  if (KStringBuilder::Equals(root->fMagic, kHeFSMagic) && root->fVersion == kHeFSVersion) {
     err_global_get() = kErrorSuccess;
 
     return YES;
@@ -706,8 +738,8 @@ _Output Bool HeFileSystemParser::Format(_Input _Output DriveTrait* drive, _Input
   rt_copy_memory((VoidPtr) "fs/hefs-packet", drive->fPacket.fPacketMime,
                  rt_string_len("fs/hefs-packet"));
 
-  urt_copy_memory((VoidPtr) part_name, root.fVolName, urt_string_len(part_name));
-  rt_copy_memory((VoidPtr) kHeFSMagic, root.fMagic, kHeFSMagicLen - 1);
+  urt_copy_memory((VoidPtr) part_name, root->fVolName, urt_string_len(part_name) + 1);
+  rt_copy_memory((VoidPtr) kHeFSMagic, root->fMagic, kHeFSMagicLen - 1);
 
   if (drive->fLbaStart > drive->fLbaEnd) {
     err_global_get() = kErrorDiskIsCorrupted;
@@ -715,58 +747,58 @@ _Output Bool HeFileSystemParser::Format(_Input _Output DriveTrait* drive, _Input
     return NO;
   }
 
-  root.fBadSectors = 0;
+  root->fBadSectors = 0;
 
-  root.fSectorCount = drv_std_get_sector_count();
-  root.fSectorSize  = drive->fSectorSz;
+  root->fSectorCount = drv_std_get_sector_count();
+  root->fSectorSize  = drive->fSectorSz;
 
-  SizeT disk_sectors = drv_std_get_size() / root.fSectorSize;  // Get total sectors
+  const SizeT max_lba = drive->fLbaEnd / root->fSectorSize;
 
-  SizeT dir_sectors   = disk_sectors / 20;  // 5% for directory metadata
-  SizeT inode_sectors = disk_sectors / 10;  // 10% for inodes
+  const SizeT dir_max   = max_lba / 20;  // 5% for directory metadata
+  const SizeT inode_max = max_lba / 10;  // 10% for inodes
 
-  root.fStartIND = drive->fLbaStart + kHeFSINDStartOffset;
-  root.fEndIND   = root.fStartIND + dir_sectors;
+  root->fStartIND = drive->fLbaStart + kHeFSINDStartOffset;
+  root->fEndIND   = root->fStartIND + dir_max;
 
-  root.fStartIN = root.fEndIND - kHeFSINDStartOffset;
-  root.fEndIN   = root.fStartIN + inode_sectors;
+  root->fStartIN = root->fEndIND - kHeFSINDStartOffset;
+  root->fEndIN   = root->fStartIN + inode_max;
 
-  constexpr SizeT kHeFSPreallocateCount = 0x7UL;
+  constexpr SizeT kHeFSPreallocateCount = 0x2UL;
 
-  root.fINDCount = kHeFSPreallocateCount;
+  root->fINDCount = kHeFSPreallocateCount;
 
-  root.fDiskSize   = drv_std_get_size();
-  root.fDiskStatus = kHeFSStatusUnlocked;
+  root->fDiskSize   = drv_std_get_size();
+  root->fDiskStatus = kHeFSStatusUnlocked;
 
-  root.fDiskFlags = flags;
+  root->fDiskFlags = flags;
 
   if (drive->fKind & kMassStorageDrive) {
   } else if (drive->fKind & kHeFSOpticalDrive) {
-    root.fDiskKind = kHeFSOpticalDrive;
+    root->fDiskKind = kHeFSOpticalDrive;
   } else {
-    root.fDiskKind = kHeFSUnknown;
+    root->fDiskKind = kHeFSUnknown;
   }
 
-  root.fReserved  = 0;
-  root.fReserved1 = 0;
+  root->fReserved  = 0;
+  root->fReserved1 = 0;
 
-  root.fVersion = kHeFSVersion;
+  root->fVersion = kHeFSVersion;
 
-  root.fVID = kHeFSInvalidVID;
+  root->fVID = kHeFSInvalidVID;
 
-  root.fChecksum = ke_calculate_crc32((Char*) &root, sizeof(HEFS_BOOT_NODE));
+  root->fChecksum = ke_calculate_crc32((Char*) &root, sizeof(HEFS_BOOT_NODE));
 
   drive->fPacket.fPacketLba     = drive->fLbaStart;
   drive->fPacket.fPacketSize    = sizeof(HEFS_BOOT_NODE);
-  drive->fPacket.fPacketContent = &root;
+  drive->fPacket.fPacketContent = root;
 
   drive->fOutput(drive->fPacket);
 
   (Void)(kout << "Drive kind: " << drive->fProtocol() << kendl);
-  (Void)(kout8 << u8"Partition name: " << root.fVolName << kendl8);
-  (Void)(kout << "Start IND: " << hex_number(root.fStartIND) << kendl);
-  (Void)(kout << "Number of catalogs: " << hex_number(root.fINDCount) << kendl);
-  (Void)(kout << "Sector size: " << hex_number(root.fSectorSize) << kendl);
+  (Void)(kout8 << u8"Partition name: " << root->fVolName << kendl8);
+  (Void)(kout << "Start IND: " << hex_number(root->fStartIND) << kendl);
+  (Void)(kout << "Number of IND: " << hex_number(root->fINDCount) << kendl);
+  (Void)(kout << "Sector size: " << hex_number(root->fSectorSize) << kendl);
 
   if (!drive->fPacket.fPacketGood) {
     err_global_get() = kErrorDiskIsCorrupted;
@@ -774,40 +806,9 @@ _Output Bool HeFileSystemParser::Format(_Input _Output DriveTrait* drive, _Input
     return NO;
   }
 
-  HEFS_INDEX_NODE_DIRECTORY dir;
-
-  urt_copy_memory((VoidPtr) u8".deleted", dir.fName, urt_string_len(u8".deleted"));
-
-  dir.fFlags = flags;
-  dir.fKind  = kHeFSFileKindDirectory;
-
-  dir.fCreated = 0;
-  dir.fDeleted = 1;  /// TODO: Add current time.
-
-  dir.fEntryCount = 0;
-
-  dir.fIndexNodeChecksum = 0;
-
-  dir.fUID  = 0;
-  dir.fGID  = 0;
-  dir.fMode = 0;
-
-  dir.fColor  = kHeFSBlack;
-  dir.fChild  = 0;
-  dir.fParent = 0;
-  dir.fNext   = 0;
-  dir.fPrev   = 0;
-
-  dir.fChecksum = ke_calculate_crc32((Char*) &dir, sizeof(HEFS_INDEX_NODE_DIRECTORY));
-
-  drive->fPacket.fPacketLba     = root.fStartIND;
-  drive->fPacket.fPacketSize    = sizeof(HEFS_INDEX_NODE_DIRECTORY);
-  drive->fPacket.fPacketContent = &dir;
-
-  drive->fOutput(drive->fPacket);
-
   const Utf8Char* kFileMap[kHeFSPreallocateCount] = {
-      u8"/", u8"/boot", u8"/system", u8"/devices", u8"/network", u8"/users", u8"/home",
+      u8"/",
+      u8"/boot",
   };
 
   for (SizeT i = 0; i < kHeFSPreallocateCount; ++i) {
@@ -832,7 +833,7 @@ _Output Bool HeFileSystemParser::Format(_Input _Output DriveTrait* drive, _Input
 /// @return If it was sucessful, see err_local_get().
 _Output Bool HeFileSystemParser::CreateDirectory(_Input DriveTrait* drive, _Input const Int32 flags,
                                                  const Utf8Char* dir) {
-  HEFS_BOOT_NODE root;
+  HEFS_BOOT_NODE* root = (HEFS_BOOT_NODE*) mm_new_heap(sizeof(HEFS_BOOT_NODE), Yes, No);
 
   kout << "CreateDirectory...\r";
 
@@ -841,11 +842,11 @@ _Output Bool HeFileSystemParser::CreateDirectory(_Input DriveTrait* drive, _Inpu
 
   drive->fPacket.fPacketLba     = drive->fLbaStart;
   drive->fPacket.fPacketSize    = sizeof(HEFS_BOOT_NODE);
-  drive->fPacket.fPacketContent = &root;
+  drive->fPacket.fPacketContent = root;
 
   drive->fInput(drive->fPacket);
 
-  if (!KStringBuilder::Equals(root.fMagic, kHeFSMagic) || root.fVersion != kHeFSVersion) {
+  if (!KStringBuilder::Equals(root->fMagic, kHeFSMagic) || root->fVersion != kHeFSVersion) {
     err_global_get() = kErrorDiskIsCorrupted;
 
     kout << "Invalid Boot Node, this can't continue!\r";
@@ -853,11 +854,20 @@ _Output Bool HeFileSystemParser::CreateDirectory(_Input DriveTrait* drive, _Inpu
     return NO;
   }
 
-  if (Detail::hefsi_allocate_index_directory_node(root, drive, dir, flags)) {
-    Detail::hefsi_balance_filesystem(root, drive);
+  auto name = new Utf8Char[urt_string_len(dir) + 1];
+
+  urt_copy_memory((VoidPtr) dir, name, urt_string_len(dir) + 1);
+
+  if (Detail::hefsi_allocate_index_directory_node(root, drive, name, flags)) {
+    mm_delete_heap((VoidPtr) root);
+    delete[] name;
     return YES;
   }
 
+  mm_delete_heap((VoidPtr) root);
+
+  delete[] name;
+
   return NO;
 }
 
@@ -874,8 +884,8 @@ _Output Bool HeFileSystemParser::CreateFile(_Input DriveTrait* drive, _Input con
   NE_UNUSED(dir);
   NE_UNUSED(name);
 
-  HEFS_BOOT_NODE  root;
-  HEFS_INDEX_NODE node;
+  HEFS_INDEX_NODE* node = (HEFS_INDEX_NODE*) RTL_ALLOCA(sizeof(HEFS_INDEX_NODE));
+  HEFS_BOOT_NODE*  root = (HEFS_BOOT_NODE*) RTL_ALLOCA(sizeof(HEFS_BOOT_NODE));
 
   kout << "CreateFile...\r";
 
@@ -884,7 +894,7 @@ _Output Bool HeFileSystemParser::CreateFile(_Input DriveTrait* drive, _Input con
 
   drive->fPacket.fPacketLba     = drive->fLbaStart;
   drive->fPacket.fPacketSize    = sizeof(HEFS_BOOT_NODE);
-  drive->fPacket.fPacketContent = &root;
+  drive->fPacket.fPacketContent = root;
 
   drive->fInput(drive->fPacket);
 
@@ -896,23 +906,21 @@ _Output Bool HeFileSystemParser::CreateFile(_Input DriveTrait* drive, _Input con
     return NO;
   }
 
-  node.fAccessed = 0;
-  node.fCreated  = 1UL;
-  node.fDeleted  = 0;
-  node.fModified = 0;
-  node.fSize     = 0;
-  node.fKind     = kHeFSFileKindRegular;
-  node.fFlags    = flags;
-  node.fChecksum = 0;
-  node.fChecksum = ke_calculate_crc32((Char*) &node, sizeof(HEFS_INDEX_NODE));
-  node.fGID      = 0;
-  node.fUID      = 0;
+  node->fAccessed = 0;
+  node->fCreated  = 1UL;
+  node->fDeleted  = 0;
+  node->fModified = 0;
+  node->fSize     = 0;
+  node->fKind     = kHeFSFileKindRegular;
+  node->fFlags    = flags;
+  node->fChecksum = 0;
+  node->fChecksum = ke_calculate_crc32((Char*) &node, sizeof(HEFS_INDEX_NODE));
+  node->fGID      = 0;
+  node->fUID      = 0;
 
-  urt_copy_memory((VoidPtr) name, node.fName, urt_string_len(name));
+  urt_copy_memory((VoidPtr) name, node->fName, urt_string_len(name) + 1);
 
   if (Detail::hefsi_allocate_index_node(root, drive, dir, node)) {
-    Detail::hefsi_balance_filesystem(root, drive);
-
     return YES;
   }
 
@@ -935,8 +943,6 @@ Boolean fs_init_hefs(Void) noexcept {
 
   parser.Format(&kMountPoint, kHeFSEncodingUTF8, kHeFSDefaultVoluneName);
 
-  parser.CreateFile(&kMountPoint, kHeFSEncodingUTF8, u8"/", u8"bootnet.efi");
-
   return YES;
 }
 }  // namespace Kernel::HeFS
diff --git a/tooling/fsck.hefs.cc b/tooling/fsck.hefs.cc
index d566e2a6..05cf0660 100644
--- a/tooling/fsck.hefs.cc
+++ b/tooling/fsck.hefs.cc
@@ -8,8 +8,8 @@
 #include <cstdlib>
 
 int main(int argc, char** argv) {
-    (void)(argc);
-    (void)(argv);
+  (void) (argc);
+  (void) (argv);
 
-    return EXIT_FAILURE;
+  return EXIT_FAILURE;
 }
\ No newline at end of file