feat(kernel): new HeFS version, scheduler allocation tree improvements and reintroduce VEPM.0.0.2e1

why?

 - The extents structure on HeFS has to be clearer.
 - The allocation tracker group has to be organized according to pointer size.
 - VEPM was scraped because HeFS took time, so now I can focus on it now.

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

10 files changed, 258 insertions, 296 deletions

diff --git a/dev/boot/modules/SysChk/amd64-ahci-epm.json b/dev/boot/modules/SysChk/amd64-ahci-epm.json
index 3c56cfe8..91c95941 100644
--- a/dev/boot/modules/SysChk/amd64-ahci-epm.json
+++ b/dev/boot/modules/SysChk/amd64-ahci-epm.json
@@ -32,6 +32,7 @@
     "__AHCI__",
     "__SYSCHK__",
     "BOOTZ_EPM_SUPPORT",
+    "__NE_VEPM__",
     "__NE_MODULAR_KERNEL_COMPONENTS__",
     "kChkVersionHighest=0x0100",
     "kChkVersionLowest=0x0100",
diff --git a/dev/boot/modules/SysChk/amd64-pio-epm.json b/dev/boot/modules/SysChk/amd64-pio-epm.json
index 14a804d0..b1b95d8d 100644
--- a/dev/boot/modules/SysChk/amd64-pio-epm.json
+++ b/dev/boot/modules/SysChk/amd64-pio-epm.json
@@ -33,6 +33,7 @@
     "__NE_AMD64__",
     "__ATA_PIO__",
     "BOOTZ_EPM_SUPPORT",
+    "__NE_VEPM__",
     "kChkVersionHighest=0x0100",
     "kChkVersionLowest=0x0100",
     "kChkVersion=0x0100"
diff --git a/dev/kernel/FSKit/HeFS.h b/dev/kernel/FSKit/HeFS.h
index 255a5381..27fe2838 100644
--- a/dev/kernel/FSKit/HeFS.h
+++ b/dev/kernel/FSKit/HeFS.h
@@ -17,7 +17,7 @@
 /// @file HeFS.h

 /// @brief HeFS filesystem support.

 

-#define kHeFSVersion (0x0102)

+#define kHeFSVersion (0x0103)

 #define kHeFSMagic "  HeFS"

 #define kHeFSMagicLen (8)

 

@@ -37,7 +37,7 @@ struct HEFS_INDEX_NODE;
 struct HEFS_INDEX_NODE_DIRECTORY;

 struct HEFS_JOURNAL_NODE;

 

-enum {

+enum : UInt8 {

   kHeFSHardDrive         = 0xC0,  // Hard Drive

   kHeFSSolidStateDrive   = 0xC1,  // Solid State Drive

   kHeFSOpticalDrive      = 0x0C,  // Blu-Ray/DVD

@@ -48,7 +48,7 @@ enum {
   kHeFSDriveCount        = 7,

 };

 

-enum {

+enum : UInt8 {

   kHeFSStatusUnlocked = 0x18,

   kHeFSStatusLocked,

   kHeFSStatusError,

@@ -56,18 +56,25 @@ enum {
   kHeFSStatusCount,

 };

 

-enum {

-  kHeFSEncodingUTF8 = 0x00,

-  kHeFSEncodingUTF16,

-  kHeFSEncodingUTF32,

-  kHeFSEncodingUTF16BE,

-  kHeFSEncodingUTF16LE,

-  kHeFSEncodingUTF32BE,

-  kHeFSEncodingUTF32LE,

-  kHeFSEncodingUTF8BE,

-  kHeFSEncodingUTF8LE,

-  kHeFSEncodingBinary,

-  kHeFSEncodingCount,

+enum : UInt16 {

+  kHeFSEncodingFlagsUTF8 = 0x50,

+  kHeFSEncodingFlagsUTF16,

+  kHeFSEncodingFlagsUTF32,

+  kHeFSEncodingFlagsUTF16BE,

+  kHeFSEncodingFlagsUTF16LE,

+  kHeFSEncodingFlagsUTF32BE,

+  kHeFSEncodingFlagsUTF32LE,

+  kHeFSEncodingFlagsUTF8BE,

+  kHeFSEncodingFlagsUTF8LE,

+  kHeFSEncodingFlagsBinary,

+  kHeFSEncodingFlagsCount = 11,

+  kHeFSFlagsNone          = 0,

+  kHeFSFlagsReadOnly      = 0x100,

+  kHeFSFlagsHidden,

+  kHeFSFlagsSystem,

+  kHeFSFlagsArchive,

+  kHeFSFlagsDevice,

+  kHeFSFlagsCount = 5

 };

 

 inline constexpr UInt16 kHeFSFileKindRegular      = 0x00;

@@ -107,10 +114,9 @@ struct PACKED HEFS_BOOT_NODE final {
   Kernel::UInt8    fDiskKind;  /// @brief Kind of the drive. (Hard Drive, Solid State Drive, Optical

                                /// Drive, etc).

   Kernel::UInt8  fEncoding;    /// @brief Encoding of the filesystem. (UTF-8, UTF-16, etc).

-  Kernel::UInt64 fStartIND;    /// @brief Start of the INode tree.

-  Kernel::UInt64

-      fEndIND;  /// @brief End of the INode tree. it is used to track down the last ind offset.

-  Kernel::UInt64 fINDCount;  /// @brief Number of leafs in the INode tree.

+  Kernel::UInt64 fStartIND;    /// @brief Start of the INode directory tree.

+  Kernel::UInt64 fEndIND;      /// @brief End of the INode directory tree.

+  Kernel::UInt64 fINDCount;    /// @brief Number of leafs in the INode tree.

   Kernel::UInt64 fDiskSize;  /// @brief Size of the disk. (Could be a virtual size, that is not the

                              /// real size of the disk.)

   Kernel::UInt16 fDiskStatus;  /// @brief Status of the disk. (locked, unlocked, error, invalid).

@@ -146,9 +152,16 @@ struct PACKED HEFS_INDEX_NODE final {
   Kernel::UInt32 fUID, fGID;  /// @brief User ID and Group ID of the file.

   Kernel::UInt32 fMode;       /// @brief File mode. (read, write, execute, etc).

 

-  Kernel::UInt64 fSlices[kHeFSSliceCount];  /// @brief block slice.

+  /// @brief Extents system by using blocks

+  /// @details Using an offset to ask fBase, and fLength to compute each slice's length.

+  Kernel::UInt64 fOffsetSlices;

 

-  Kernel::Char fPad[317];

+  struct {

+    Kernel::UInt32 fBase;

+    Kernel::UInt32 fLength;

+  } fSlices[kHeFSSliceCount];  /// @brief block slice

+

+  Kernel::Char fPad[309];

 };

 

 enum {

@@ -162,7 +175,7 @@ enum {
 /// @details This structure is used to store the directory information of a file.

 /// @note The directory node is a special type of INode that contains the directory entries.

 struct PACKED HEFS_INDEX_NODE_DIRECTORY final {

-  Kernel::UInt64 fHashPath;  /// @brief Directory name.

+  Kernel::UInt64 fHashPath;  /// @brief Directory path as FNV hash.

 

   Kernel::UInt32 fFlags;  /// @brief File flags.

   Kernel::UInt16 fKind;   /// @brief File kind. (Regular, Directory, Block, Character, FIFO, Socket,

@@ -271,23 +284,23 @@ inline const Char* hefs_drive_kind_to_string(UInt8 kind) noexcept {
 

 inline const Char* hefs_encoding_to_string(UInt8 encoding) noexcept {

   switch (encoding) {

-    case kHeFSEncodingUTF8:

+    case kHeFSEncodingFlagsUTF8:

       return "UTF-8";

-    case kHeFSEncodingUTF16:

+    case kHeFSEncodingFlagsUTF16:

       return "UTF-16";

-    case kHeFSEncodingUTF32:

+    case kHeFSEncodingFlagsUTF32:

       return "UTF-32";

-    case kHeFSEncodingUTF16BE:

+    case kHeFSEncodingFlagsUTF16BE:

       return "UTF-16BE";

-    case kHeFSEncodingUTF16LE:

+    case kHeFSEncodingFlagsUTF16LE:

       return "UTF-16LE";

-    case kHeFSEncodingUTF32BE:

+    case kHeFSEncodingFlagsUTF32BE:

       return "UTF-32BE";

-    case kHeFSEncodingUTF32LE:

+    case kHeFSEncodingFlagsUTF32LE:

       return "UTF-32LE";

-    case kHeFSEncodingUTF8BE:

+    case kHeFSEncodingFlagsUTF8BE:

       return "UTF-8BE";

-    case kHeFSEncodingUTF8LE:

+    case kHeFSEncodingFlagsUTF8LE:

       return "UTF-8LE";

     default:

       return "Unknown";

@@ -318,17 +331,17 @@ inline const Char* hefs_file_kind_to_string(UInt16 kind) noexcept {
 

 inline const Char* hefs_file_flags_to_string(UInt32 flags) noexcept {

   switch (flags) {

-    case 0x00:

+    case kHeFSFlagsNone:

       return "No Flags";

-    case 0x01:

+    case kHeFSFlagsReadOnly:

       return "Read Only";

-    case 0x02:

+    case kHeFSFlagsHidden:

       return "Hidden";

-    case 0x04:

+    case kHeFSFlagsSystem:

       return "System";

-    case 0x08:

+    case kHeFSFlagsArchive:

       return "Archive";

-    case 0x10:

+    case kHeFSFlagsDevice:

       return "Device";

     default:

       return "Unknown";

@@ -382,9 +395,6 @@ class HeFileSystemParser final {
 

   _Output Bool INodeDirectoryCtl_(_Input DriveTrait* drive, _Input const Int32 flags,

                                   const Utf8Char* dir, const BOOL delete_or_create);

-

-  UInt32 mDriveIndex{MountpointInterface::kDriveIndexA};  /// @brief The drive index which this

-                                                          /// filesystem is mounted on.

 };

 

 /// @brief Initialize HeFS inside the main disk.

diff --git a/dev/kernel/src/FS/HeFS+FileSystemParser.cc b/dev/kernel/src/FS/HeFS+FileSystemParser.cc
index e8ffd02a..b3e1d4d0 100644
--- a/dev/kernel/src/FS/HeFS+FileSystemParser.cc
+++ b/dev/kernel/src/FS/HeFS+FileSystemParser.cc
@@ -23,15 +23,18 @@ namespace Kernel {
 namespace Detail {
   /// @brief Forward declarations of internal functions.
 
+  /***********************************************************************************/
   /// @brief Traverse the RB-Tree of the filesystem.
   /// @param dir The directory to traverse.
   /// @param start The starting point of the traversal.
   /// @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, DriveTrait* mnt, const Lba& start_ind,
                           Lba& start, const BOOL try_new = NO);
 
+  /***********************************************************************************/
   /// @brief Get the index node of a file or directory.
   /// @param root The root node of the filesystem.
   /// @param mnt The drive to read from.
@@ -39,34 +42,30 @@ namespace Detail {
   /// @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_index_node(
-      HEFS_BOOT_NODE* root, DriveTrait* mnt, const Utf8Char* dir_name, const Utf8Char* file_name,
-      UInt8 kind, SizeT* cnt);
-
-  /// @brief Get the index node size.
-  /// @param root The root node of the filesystem.
-  /// @param mnt The drive 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 SizeT
-      hefsi_fetch_index_node_size(HEFS_BOOT_NODE* root, DriveTrait* mnt, const Utf8Char* dir_name,
-                                  const Utf8Char* file_name, UInt8 kind);
+  /***********************************************************************************/
+  STATIC ATTRIBUTE(unused) _Output HEFS_INDEX_NODE* hefsi_fetch_in(HEFS_BOOT_NODE* root,
+                                                                   DriveTrait*     mnt,
+                                                                   const Utf8Char* dir_name,
+                                                                   const Utf8Char* file_name,
+                                                                   UInt8 kind, SizeT* cnt);
 
+  /***********************************************************************************/
   /// @brief Allocate a new index node->
   /// @param root The root node of the filesystem.
   /// @param mnt The drive 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,
                              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 mnt The drive to read/write from.
   /// @return Status, see err_global_get().
+  /***********************************************************************************/
   STATIC ATTRIBUTE(unused) _Output BOOL hefsi_balance_ind(HEFS_BOOT_NODE* root, DriveTrait* mnt);
 
   /// @brief Alllocate IND from boot node.
@@ -253,71 +252,6 @@ namespace Detail {
     kout << "RB-Tree has been rotated.\r";
   }
 
-  /// @brief Get the index node size.
-  /// @param root The root node of the filesystem.
-  /// @param mnt The drive 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 SizeT
-      hefsi_fetch_index_node_size(HEFS_BOOT_NODE* root, DriveTrait* mnt, const Utf8Char* dir_name,
-                                  const Utf8Char* file_name, UInt8 kind) {
-    if (mnt) {
-      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;
-
-      while (YES) {
-        mnt->fPacket.fPacketLba     = start;
-        mnt->fPacket.fPacketSize    = sizeof(HEFS_INDEX_NODE_DIRECTORY);
-        mnt->fPacket.fPacketContent = dir;
-
-        mnt->fInput(mnt->fPacket);
-
-        if (!mnt->fPacket.fPacketGood) {
-          err_global_get() = kErrorFileNotFound;
-
-          return 0;
-        }
-
-        if (dir->fKind == kHeFSFileKindDirectory) {
-          if (hefsi_hash_64(dir_name) == dir->fHashPath ||
-              KStringBuilder::Equals(dir_name, kHeFSSearchAllStr)) {
-            for (SizeT inode_index = 0UL; inode_index < kHeFSSliceCount; inode_index += 2) {
-              mnt->fPacket.fPacketLba     = dir->fINSlices[inode_index];
-              mnt->fPacket.fPacketSize    = sizeof(HEFS_INDEX_NODE);
-              mnt->fPacket.fPacketContent = node;
-              mnt->fInput(mnt->fPacket);
-
-              if (hefsi_hash_64(file_name) == node->fHashPath && node->fKind == kind) {
-                if (node->fKind == kHeFSFileKindDirectory) {
-                  sz += hefsi_fetch_index_node_size(root, mnt, dir_name, file_name, kind);
-                } else {
-                  sz = node->fSize;
-                }
-
-                return sz;
-              }
-            }
-          } else if (dir->fHashPath == 0) {
-            break;
-          }
-        }
-      }
-
-      err_global_get() = kErrorSuccess;
-      return sz;
-    }
-
-    err_global_get() = kErrorFileNotFound;
-    return 0;
-  }
-
   /// @brief Alllocate IND from boot node.
   /// @param root The root node of the filesystem.
   /// @param mnt The drive to read from.
@@ -520,9 +454,11 @@ namespace Detail {
   /// @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_index_node(
-      HEFS_BOOT_NODE* root, DriveTrait* mnt, const Utf8Char* dir_name, const Utf8Char* file_name,
-      UInt8 kind, SizeT* cnt) {
+  STATIC ATTRIBUTE(unused) _Output HEFS_INDEX_NODE* hefsi_fetch_in(HEFS_BOOT_NODE* root,
+                                                                   DriveTrait*     mnt,
+                                                                   const Utf8Char* dir_name,
+                                                                   const Utf8Char* file_name,
+                                                                   UInt8 kind, SizeT* cnt) {
     if (mnt) {
       HEFS_INDEX_NODE* node_arr = new HEFS_INDEX_NODE[*cnt];
 
@@ -536,6 +472,9 @@ namespace Detail {
 
       auto start = root->fStartIND;
 
+      if (start > root->fEndIND) return nullptr;
+      if (root->fStartIN > root->fEndIN) return nullptr;
+
       auto start_cnt = 0UL;
 
       while (YES) {
@@ -557,30 +496,21 @@ namespace Detail {
               KStringBuilder::Equals(dir_name, kHeFSSearchAllStr)) {
             if (ke_calculate_crc32((Char*) dir, sizeof(HEFS_INDEX_NODE_DIRECTORY)) !=
                 dir->fChecksum)
-              ke_panic(RUNTIME_CHECK_FILESYSTEM, "CRC32 failure on HeFS IND!");
+              ke_panic(RUNTIME_CHECK_FILESYSTEM, "CRC32 checksum failed on HeFS IND!");
 
             for (SizeT inode_index = 0UL; inode_index < kHeFSSliceCount; ++inode_index) {
               if (dir->fINSlices[inode_index] != 0) {
-                if (mnt->fPacket.fPacketGood) {
-                  if (ke_calculate_crc32((Char*) node, sizeof(HEFS_INDEX_NODE)) != node->fChecksum)
-                    ke_panic(RUNTIME_CHECK_FILESYSTEM, "CRC32 failure on HeFS IND!");
+                if (ke_calculate_crc32((Char*) node, sizeof(HEFS_INDEX_NODE)) != node->fChecksum)
+                  ke_panic(RUNTIME_CHECK_FILESYSTEM, "CRC32 failure on HeFS IND!");
 
-                  if (hefsi_hash_64(file_name) == node->fHashPath && node->fKind == kind) {
-                    node_arr[start_cnt] = *node;
-                    ++start_cnt;
+                if (hefsi_hash_64(file_name) == node->fHashPath && node->fKind == kind) {
+                  node_arr[start_cnt] = *node;
+                  ++start_cnt;
 
-                    if (start_cnt > *cnt) {
-                      return node_arr;
-                    }
+                  if (start_cnt > *cnt) {
+                    err_global_get() = kErrorSuccess;
+                    return node_arr;
                   }
-                } else {
-                  err_global_get() = kErrorDiskIsCorrupted;
-
-                  delete[] node_arr;
-
-                  node_arr = nullptr;
-
-                  return nullptr;
                 }
               }
             }
@@ -592,6 +522,9 @@ namespace Detail {
         hefsi_traverse_tree(dir, mnt, root->fStartIND, start, YES);
         if (start > root->fEndIND || start == 0) break;
       }
+
+      err_global_get() = kErrorSuccess;
+      return node_arr;
     }
 
     kout << "Error: Failed to find index node->\r";
@@ -710,7 +643,7 @@ namespace Detail {
               mnt->fOutput(mnt->fPacket);
 
               mm_delete_heap(dir);
-              
+
               return YES;
             }
           }
@@ -921,11 +854,12 @@ _Output Bool HeFileSystemParser::Format(_Input _Output DriveTrait* drive, _Input
 
   drive->fOutput(drive->fPacket);
 
-  (Void)(kout << "Drive kind: " << drive->fProtocol() << kendl);
-  (Void)(kout8 << u8"Volume name: " << root->fVolName << kendl8);
+  (Void)(kout << "Protocol: " << drive->fProtocol() << kendl);
+  (Void)(kout8 << u8"Volume 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);
+  (Void)(kout << "Sector Size: " << hex_number(root->fSectorSize) << kendl);
+  (Void)(kout << "Drive Kind:" << Detail::hefs_drive_kind_to_string(root->fDiskKind) << kendl);
 
   if (!drive->fPacket.fPacketGood) {
     err_global_get() = kErrorDiskIsCorrupted;
@@ -937,7 +871,7 @@ _Output Bool HeFileSystemParser::Format(_Input _Output DriveTrait* drive, _Input
                                                      u8"/network", u8"/devices", u8"/media"};
 
   for (SizeT i = 0; i < kHeFSPreallocateCount; ++i) {
-    this->CreateINodeDirectory(drive, kHeFSEncodingUTF8, kFileMap[i]);
+    this->CreateINodeDirectory(drive, kHeFSEncodingFlagsUTF8, kFileMap[i]);
   }
 
   err_global_get() = kErrorSuccess;
@@ -1128,12 +1062,16 @@ Boolean fs_init_hefs(Void) {
 
   HeFileSystemParser parser;
 
-  parser.Format(&kMountPoint, kHeFSEncodingUTF8, kHeFSDefaultVoluneName);
+  parser.Format(&kMountPoint, kHeFSEncodingFlagsUTF8, kHeFSDefaultVoluneName);
 
-  MUST_PASS(parser.CreateINode(&kMountPoint, kHeFSEncodingBinary, u8"/boot", u8".filetest"));
-  MUST_PASS(parser.DeleteINode(&kMountPoint, kHeFSEncodingBinary, u8"/boot", u8".filetest"));
-  MUST_PASS(parser.CreateINode(&kMountPoint, kHeFSEncodingBinary, u8"/network", u8".filetest"));
-  MUST_PASS(parser.DeleteINode(&kMountPoint, kHeFSEncodingBinary, u8"/network", u8".filetest"));
+  MUST_PASS(parser.CreateINode(&kMountPoint, kHeFSEncodingFlagsBinary | kHeFSFlagsReadOnly,
+                               u8"/boot", u8".filetest"));
+  MUST_PASS(parser.DeleteINode(&kMountPoint, kHeFSEncodingFlagsBinary | kHeFSFlagsReadOnly,
+                               u8"/boot", u8".filetest"));
+  MUST_PASS(parser.CreateINode(&kMountPoint, kHeFSEncodingFlagsBinary | kHeFSFlagsReadOnly,
+                               u8"/network", u8".filetest"));
+  MUST_PASS(parser.DeleteINode(&kMountPoint, kHeFSEncodingFlagsBinary | kHeFSFlagsReadOnly,
+                               u8"/network", u8".filetest"));
 
   return YES;
 }
diff --git a/dev/kernel/src/MemoryMgr.cc b/dev/kernel/src/MemoryMgr.cc
index cb33753d..001f970a 100644
--- a/dev/kernel/src/MemoryMgr.cc
+++ b/dev/kernel/src/MemoryMgr.cc
@@ -26,7 +26,7 @@
 //! @brief Heap algorithm that serves as the main memory manager.
 
 #define kMemoryMgrMagic (0xD4D75)
-#define kMemoryMgrAlignSz (4)
+#define kMemoryMgrAlignSz (4U)
 
 namespace Kernel {
 /// @brief Implementation details.
diff --git a/dev/kernel/src/Network/IPCMsg.cc b/dev/kernel/src/Network/IPCMsg.cc
index b3c9d9fd..e89e7c1b 100644
--- a/dev/kernel/src/Network/IPCMsg.cc
+++ b/dev/kernel/src/Network/IPCMsg.cc
@@ -9,8 +9,10 @@
 #include <NetworkKit/IPC.h>
 
 namespace Kernel {
+/***********************************************************************************/
 /// @internal internal use for IPC system only.
 /// @brief The internal sanitize function.
+/***********************************************************************************/
 Bool ipc_int_sanitize_packet(IPC_MSG* pckt) {
   auto endian = RTL_ENDIAN(pckt, ((Char*) pckt)[0]);
 
@@ -45,9 +47,11 @@ ipc_check_failed:
   return false;
 }
 
+/***********************************************************************************/
 /// @brief Sanitize packet function
 /// @retval true packet is correct.
 /// @retval false packet is incorrect and process has crashed.
+/***********************************************************************************/
 Bool ipc_sanitize_packet(IPC_MSG* pckt) {
   if (!pckt || !ipc_int_sanitize_packet(pckt)) {
     return false;
@@ -56,9 +60,11 @@ Bool ipc_sanitize_packet(IPC_MSG* pckt) {
   return true;
 }
 
+/***********************************************************************************/
 /// @brief Construct packet function
 /// @retval true packet is correct.
 /// @retval false packet is incorrect and process has crashed.
+/***********************************************************************************/
 Bool ipc_construct_packet(_Output IPC_MSG** pckt_in) {
   // don't act if it's not even valid.
   if (!pckt_in) return false;
@@ -87,9 +93,11 @@ Bool ipc_construct_packet(_Output IPC_MSG** pckt_in) {
   return No;
 }
 
+/***********************************************************************************/
 /// @brief Pass message from **src** to **target**
 /// @param src Source message.
 /// @param target Target message.
+/***********************************************************************************/
 Bool IPC_MSG::Pass(IPC_MSG* src, IPC_MSG* target) noexcept {
   if (src && target && (target != src)) {
     if (src->IpcMsgSz > target->IpcMsgSz) return No;
diff --git a/dev/kernel/src/UserProcessScheduler.cc b/dev/kernel/src/UserProcessScheduler.cc
index 45a95b5b..dbe3882f 100644
--- a/dev/kernel/src/UserProcessScheduler.cc
+++ b/dev/kernel/src/UserProcessScheduler.cc
@@ -97,6 +97,7 @@ Void USER_PROCESS::Wake(Bool should_wakeup) {
 
 /***********************************************************************************/
 /** @brief Allocate pointer to heap tree. */
+/** @param tree The tree to calibrate */
 /***********************************************************************************/
 
 STATIC USER_PROCESS::USER_HEAP_TREE* sched_try_go_upper_heap_tree(
@@ -141,13 +142,13 @@ ErrorOr<VoidPtr> USER_PROCESS::New(SizeT sz, SizeT pad_amount) {
   if (!this->HeapTree) {
     this->HeapTree = new USER_HEAP_TREE();
 
-    this->HeapTree->MemoryColor = USER_HEAP_TREE::kBlackMemory;
-
     this->HeapTree->MemoryEntryPad  = pad_amount;
     this->HeapTree->MemoryEntrySize = sz;
 
     this->HeapTree->MemoryEntry = ptr;
 
+    this->HeapTree->MemoryColor = USER_HEAP_TREE::kBlackMemory;
+
     this->HeapTree->MemoryPrev   = nullptr;
     this->HeapTree->MemoryNext   = nullptr;
     this->HeapTree->MemoryParent = nullptr;
@@ -163,32 +164,41 @@ ErrorOr<VoidPtr> USER_PROCESS::New(SizeT sz, SizeT pad_amount) {
 
       prev_entry = entry;
 
-      if (entry->MemoryNext) {
-        is_parent = NO;
-        entry     = entry->MemoryNext;
-      } else if (entry->MemoryChild) {
+      if (entry->MemoryColor == USER_HEAP_TREE::kBlackMemory) break;
+
+      if (entry->MemoryChild && entry->MemoryChild->MemoryEntrySize > 0 &&
+          entry->MemoryChild->MemoryEntrySize == sz) {
         entry     = entry->MemoryChild;
         is_parent = YES;
+      } else if (entry->MemoryNext && entry->MemoryChild->MemoryEntrySize > 0 &&
+                 entry->MemoryNext->MemoryEntrySize == sz) {
+        is_parent = NO;
+        entry     = entry->MemoryNext;
       } else {
         entry = sched_try_go_upper_heap_tree(entry);
+        if (entry && entry->MemoryColor == USER_HEAP_TREE::kBlackMemory) break;
       }
     }
 
-    if (!entry) entry = new USER_HEAP_TREE();
+    auto new_entry = new USER_HEAP_TREE();
 
-    entry->MemoryEntry     = ptr;
-    entry->MemoryEntrySize = sz;
-    entry->MemoryEntryPad  = pad_amount;
+    new_entry->MemoryEntry     = ptr;
+    new_entry->MemoryEntrySize = sz;
+    new_entry->MemoryEntryPad  = pad_amount;
+    new_entry->MemoryParent    = entry;
+    new_entry->MemoryChild     = nullptr;
+    new_entry->MemoryNext      = nullptr;
+    new_entry->MemoryPrev      = nullptr;
 
-    if (is_parent) {
-      entry->MemoryParent     = prev_entry;
-      prev_entry->MemoryChild = entry;
+    new_entry->MemoryColor  = USER_HEAP_TREE::kBlackMemory;
+    prev_entry->MemoryColor = USER_HEAP_TREE::kRedMemory;
 
-      prev_entry->MemoryColor = USER_HEAP_TREE::kBlackMemory;
-      entry->MemoryColor      = USER_HEAP_TREE::kRedMemory;
+    if (is_parent) {
+      prev_entry->MemoryChild = new_entry;
+      new_entry->MemoryParent = prev_entry;
     } else {
-      prev_entry->MemoryNext = entry;
-      entry->MemoryPrev      = prev_entry;
+      prev_entry->MemoryNext = new_entry;
+      new_entry->MemoryPrev  = prev_entry;
     }
   }
 
diff --git a/docs/tex/hefs.tex b/docs/tex/hefs.tex
index 5aa9c59b..afafc472 100644
--- a/docs/tex/hefs.tex
+++ b/docs/tex/hefs.tex
@@ -1,157 +1,151 @@
 \documentclass{article}
-\usepackage[a4paper, margin=1in]{geometry}
-\usepackage{amsmath, amssymb}
-\usepackage{listings}
-\usepackage{xcolor}
-\usepackage{graphicx}
-\usepackage{enumitem}
-\usepackage{caption}
+\usepackage[utf8]{inputenc}
+\usepackage{geometry}
 \usepackage{longtable}
-
-\definecolor{lightgray}{gray}{0.95}
-
-\lstdefinestyle{cstyle}{
-  language=C++,
-  backgroundcolor=\color{lightgray},
-  basicstyle=\ttfamily\small,
-  keywordstyle=\color{blue},
-  commentstyle=\color{green!60!black},
-  stringstyle=\color{orange},
-  numbers=left,
-  numberstyle=\tiny,
-  breaklines=true,
-  frame=single,
-  showstringspaces=false
-}
-
-\title{HeFS (High-Throughput Extended File System) Specification}
+\usepackage{listings}
+\geometry{margin=1in}
+\title{HeFS Filesystem Specification (v0x0103)}
 \author{Amlal El Mahrouss}
-\date{2024-2025}
+\date{2025}
 
 \begin{document}
 
 \maketitle
 
 \section{Overview}
-HeFS is a high-throughput filesystem designed for NeKernel. It implements a robust directory structure based on red-black trees, uses slice-linked blocks for file storage, and includes CRC32-based integrity checks. Designed for desktop, server, and embedded contexts, it prioritizes performance, corruption recovery, and extensibility.
+The High-throughput Extended File System (HeFS) is a custom filesystem tailored for performance, structure, and compact representation. It uses red-black trees for directory indexing, sparse block slicing for file layout, and fixed-size metadata structures optimized for 512-byte sector alignment.
 
-\section{Boot Node Structure}
-\begin{longtable}{|l|l|p{8cm}|}
+\section{Constants and Macros}
+\begin{longtable}{|l|l|}
 \hline
-\textbf{Field} & \textbf{Type} & \textbf{Description} \\
+\textbf{Name} & \textbf{Value / Description} \\
 \hline
-\verb|fMagic| & \verb|char[8]| & Filesystem magic ("  HeFS") \\
-\verb|fVolName| & \verb|Utf8Char[128]| & Volume name \\
-\verb|fVersion| & \verb|UInt32| & Filesystem version (e.g., 0x0102) \\
-\verb|fBadSectors| & \verb|UInt64| & Number of bad sectors detected \\
-\verb|fSectorCount| & \verb|UInt64| & Total sector count \\
-\verb|fSectorSize| & \verb|UInt64| & Size of each sector \\
-\verb|fChecksum| & \verb|UInt32| & CRC32 checksum of the boot node \\
-\verb|fDiskKind| & \verb|UInt8| & Type of drive (e.g., HDD, SSD, USB) \\
-\verb|fEncoding| & \verb|UInt8| & Encoding mode (UTF-8, UTF-16, etc.) \\
-\verb|fStartIND| & \verb|UInt64| & Starting LBA of inode directory region \\
-\verb|fEndIND| & \verb|UInt64| & Ending LBA of inode directory region \\
-\verb|fINDCount| & \verb|UInt64| & Number of directory nodes allocated \\
-\verb|fDiskSize| & \verb|UInt64| & Logical size of the disk \\
-\verb|fDiskStatus| & \verb|UInt16| & Status of the disk (e.g., unlocked, locked) \\
-\verb|fDiskFlags| & \verb|UInt16| & Disk flags (e.g., read-only) \\
-\verb|fVID| & \verb|UInt16| & Virtual ID (for EPM integration) \\
+\texttt{kHeFSVersion} & 0x0103 \\
+\texttt{kHeFSMagic} & "  HeFS" (8-byte magic identifier) \\
+\texttt{kHeFSFileNameLen} & 256 characters \\
+\texttt{kHeFSPartNameLen} & 128 characters \\
+\texttt{kHeFSMinimumDiskSize} & 16 MiB \\
+\texttt{kHeFSDefaultVoluneName} & "HeFS Volume" \\
+\texttt{kHeFSINDStartOffset} & Offset after boot + dir nodes \\
+\texttt{kHeFSSearchAllStr} & "\*" (wildcard string) \\
 \hline
 \end{longtable}
 
-\section{File Types and Flags}
-\subsection*{File Kinds}
-\begin{itemize}[label=--]
-    \item \verb|0x00| --- Regular File
-    \item \verb|0x01| --- Directory
-    \item \verb|0x02| --- Block Device
-    \item \verb|0x03| --- Character Device
-    \item \verb|0x04| --- FIFO
-    \item \verb|0x05| --- Socket
-    \item \verb|0x06| --- Symbolic Link
-    \item \verb|0x07| --- Unknown
+\section{Disk and File Metadata Enums}
+
+\subsection{Drive Kind (\texttt{UInt8})}
+\begin{itemize}
+\item 0xC0: Hard Drive
+\item 0xC1: Solid State Drive
+\item 0x0C: Optical Drive
+\item 0xCC: USB Mass Storage
+\item 0xC4: SCSI Drive
+\item 0xC6: Flash Drive
+\item 0xFF: Unknown
+\end{itemize}
+
+\subsection{Disk Status (\texttt{UInt8})}
+\begin{itemize}
+\item 0x18: Unlocked
+\item 0x19: Locked
+\item 0x1A: Error
+\item 0x1B: Invalid
+\end{itemize}
+
+\subsection{Encoding Flags (\texttt{UInt16})}
+\begin{itemize}
+\item UTF-8, UTF-16, UTF-32, Binary (with endianness variants)
 \end{itemize}
 
-\subsection*{Drive Types}
-\begin{itemize}[label=--]
-    \item \verb|0xC0| --- Hard Drive
-    \item \verb|0xC1| --- Solid State Drive
-    \item \verb|0x0C| --- Optical Drive
-    \item \verb|0xCC| --- USB Mass Storage
-    \item \verb|0xC4| --- SCSI/SAS Drive
-    \item \verb|0xC6| --- Flash Drive
+\subsection{File Kinds (\texttt{UInt16})}
+\begin{itemize}
+\item 0x00: Regular File
+\item 0x01: Directory
+\item 0x02: Block Device
+\item 0x03: Character Device
+\item 0x04: FIFO
+\item 0x05: Socket
+\item 0x06: Symbolic Link
+\item 0x07: Unknown
 \end{itemize}
 
-\section{Index Node Structure}
-The `HEFS\_INDEX\_NODE` represents a file and is constrained to 512 bytes to match hardware sector boundaries. It uses a fixed set of block pointers (slices) and CRC32 checks for data integrity. Only the local file name is stored in `fName`.
+\subsection{File Flags (\texttt{UInt32})}
+\begin{itemize}
+\item ReadOnly, Hidden, System, Archive, Device
+\end{itemize}
 
-\begin{lstlisting}[style=cstyle, caption={HEFS\_INDEX\_NODE (Fits 512B)}]
-struct HEFS_INDEX_NODE {
-    UInt64   fHashPath;        // Local file name, hashed.
-    UInt32   fFlags;
-    UInt16   fKind;
-    UInt32   fSize;
-    UInt32   fChecksum;
+\section{Structures}
 
-    Boolean  fSymLink;
-    ATime    fCreated, fAccessed, fModified, fDeleted;
-    UInt32   fUID, fGID;
-    UInt32   fMode;
+\subsection{HEFS\_BOOT\_NODE}
+Acts as the superblock.
 
-    UInt64   fSlices[16];        // Data block slices (start-only)
-    Char     fPad[317];          // Padding to reach 512B
-};
-\end{lstlisting}
+\begin{itemize}
+  \item \texttt{fMagic}, \texttt{fVolName}, \texttt{fVersion}, \texttt{fChecksum}
+  \item Sector and disk geometry: \texttt{fSectorCount}, \texttt{fSectorSize}, \texttt{fBadSectors}
+  \item Drive info: \texttt{fDiskKind}, \texttt{fEncoding}, \texttt{fDiskStatus}, \texttt{fDiskFlags}, \texttt{fVID}
+  \item Tree layout: \texttt{fStartIND}, \texttt{fEndIND}, \texttt{fINDCount}
+  \item Reserved: \texttt{fStartIN}, \texttt{fEndIN}, \texttt{fReserved}, \texttt{fReserved1}
+\end{itemize}
 
-\section{Directory Node Structure}
-Directories form a red-black tree. Each node (IND) can hold up to 16 index node references and links to its parent, siblings, and children via LBAs.
+\subsection{HEFS\_INDEX\_NODE}
+Contains file metadata and block layout.
 
-\begin{lstlisting}[style=cstyle, caption={HEFS\_INDEX\_NODE\_DIRECTORY}]
-struct HEFS_INDEX_NODE_DIRECTORY {
-    UInt64   fHashPath;        // Directory path as hash
-    UInt32   fFlags;
-    UInt16   fKind;
-    UInt32   fEntryCount;
-    UInt32   fChecksum;
+\begin{itemize}
+  \item \texttt{fHashPath}, \texttt{fFlags}, \texttt{fKind}, \texttt{fSize}, \texttt{fChecksum}
+  \item Symbolic link: \texttt{fSymLink}
+  \item Time: \texttt{fCreated}, \texttt{fAccessed}, \texttt{fModified}, \texttt{fDeleted}
+  \item Ownership: \texttt{fUID}, \texttt{fGID}, \texttt{fMode}
+  \item Block data: \texttt{fOffsetSlices}, \texttt{fSlices[kHeFSSliceCount]} as (base, length) pairs
+\end{itemize}
 
-    ATime    fCreated, fAccessed, fModified, fDeleted;
-    UInt32   fUID, fGID;
-    UInt32   fMode;
+\subsection{HEFS\_INDEX\_NODE\_DIRECTORY}
+Red-black tree based directory node.
 
-    UInt64   fINSlices[16];    // Inode LBA references
+\begin{itemize}
+  \item \texttt{fHashPath}, \texttt{fFlags}, \texttt{fKind}, \texttt{fEntryCount}, \texttt{fChecksum}
+  \item Time and ownership same as inode
+  \item \texttt{fINSlices[kHeFSSliceCount]} for storing child inodes
+  \item Tree links: \texttt{fColor}, \texttt{fNext}, \texttt{fPrev}, \texttt{fChild}, \texttt{fParent}
+\end{itemize}
 
-    UInt8    fColor;            // Red/Black tree color
-    Lba      fNext, fPrev, fChild, fParent;
+\section{Timestamp Layout (ATime)}
 
-    Char     fPad[285];
-};
-\end{lstlisting}
+\texttt{ATime} is a 64-bit timestamp with the following structure:
 
-\section{Design Characteristics}
+\begin{itemize}
+  \item Bits 63-32: Year
+  \item Bits 31-24: Month
+  \item Bits 23-16: Day
+  \item Bits 15-8: Hour
+  \item Bits 7-0: Minute
+\end{itemize}
 
+Constants:
 \begin{itemize}
-    \item Red-black tree traversal for directory balancing
-    \item One-sector (512B) inode design for efficient I/O
-    \item Slice-linked file storage (fixed 16 slots)
-    \item CRC32 for boot node, inode, and directory integrity
-    \item Preallocated directory inodes to avoid runtime fragmentation
+  \item \texttt{kHeFSTimeInvalid = 0x0}
+  \item \texttt{kHeFSTimeMax = 0xFFFFFFFFFFFFFFFF - 1}
 \end{itemize}
 
-\section{Minimum Requirements}
+\section{Filesystem API}
+
+Provided by \texttt{Kernel::HeFS::HeFileSystemParser}.
 
 \begin{itemize}
-    \item Minimum disk size: 16MB
-    \item Recommended size: 8GB or more
-    \item Supported media: HDD, SSD, USB, SCSI, Flash, Optical
+  \item \texttt{Format(drive, flags, name)} - Format drive with HeFS
+  \item \texttt{CreateINodeDirectory(drive, flags, dir)}
+  \item \texttt{RemoveINodeDirectory(drive, flags, dir)}
+  \item \texttt{CreateINode(drive, flags, dir, name)}
+  \item \texttt{DeleteINode(drive, flags, dir, name)}
+  \item \texttt{WriteINode(drive, block, size, dir, name)}
+  \item \texttt{ReadINode(drive, block, size, dir, name)}
 \end{itemize}
 
-\section{Future Work}
+Internal helpers:
 \begin{itemize}
-    \item Journaling layer for recovery
-    \item Extended access control and ACL support
-    \item Logical Volume Management (LVM)
-    \item Dual boot node layout for redundancy
-    \item Self-healing and online fsck tools
+  \item \texttt{INodeCtl\_}, \texttt{INodeDirectoryCtl\_}
 \end{itemize}
 
+\section{Conclusion}
+HeFS provides a modern and compact approach to high-performance file storage. Its use of red-black trees, fixed-size metadata, slice-based sparse files, and minimal overhead makes it a strong candidate for embedded and performance-sensitive use cases.
+
 \end{document}
diff --git a/tooling/hefs.h b/tooling/hefs.h
index 99d04768..ded6cbef 100644
--- a/tooling/hefs.h
+++ b/tooling/hefs.h
@@ -43,17 +43,17 @@ enum {
 
 // Encodings
 enum {
-  kHeFSEncodingUTF8 = 0x00,
-  kHeFSEncodingUTF16,
-  kHeFSEncodingUTF32,
-  kHeFSEncodingUTF16BE,
-  kHeFSEncodingUTF16LE,
-  kHeFSEncodingUTF32BE,
-  kHeFSEncodingUTF32LE,
-  kHeFSEncodingUTF8BE,
-  kHeFSEncodingUTF8LE,
-  kHeFSEncodingBinary,
-  kHeFSEncodingCount,
+  kHeFSEncodingFlagsUTF8 = 0x00,
+  kHeFSEncodingFlagsUTF16,
+  kHeFSEncodingFlagsUTF32,
+  kHeFSEncodingFlagsUTF16BE,
+  kHeFSEncodingFlagsUTF16LE,
+  kHeFSEncodingFlagsUTF32BE,
+  kHeFSEncodingFlagsUTF32LE,
+  kHeFSEncodingFlagsUTF8BE,
+  kHeFSEncodingFlagsUTF8LE,
+  kHeFSEncodingFlagsBinary,
+  kHeFSEncodingFlagsCount,
 };
 
 // Time type
diff --git a/tooling/mkfs.hefs.cc b/tooling/mkfs.hefs.cc
index 23772023..bc1f3d3c 100644
--- a/tooling/mkfs.hefs.cc
+++ b/tooling/mkfs.hefs.cc
@@ -74,7 +74,7 @@ int main(int argc, char** argv) {
 
   bootNode.version    = kVersion;
   bootNode.diskKind   = mkfs::hefs::kHeFSHardDrive;
-  bootNode.encoding   = mkfs::hefs::kHeFSEncodingUTF8;
+  bootNode.encoding   = mkfs::hefs::kHeFSEncodingFlagsUTF8;
   bootNode.diskSize   = kDiskSize;
   bootNode.sectorSize = kSectorSize;
   bootNode.startIND   = start_ind;