From 69fffdd906c02b6ea65f5346c31719ea0f8c3bbc Mon Sep 17 00:00:00 2001
From: Amlal <amlal@nekernel.org>
Date: Tue, 6 May 2025 15:45:48 +0200
Subject: feat(kernel): Working on the last parts of HeFS V1, which will act as
 the base layer of the filesystem.

Signed-off-by: Amlal <amlal@nekernel.org>
---
 dev/kernel/FSKit/HeFS.h | 43 +++++++++++++++++++++++--------------------
 1 file changed, 23 insertions(+), 20 deletions(-)

(limited to 'dev/kernel/FSKit')

diff --git a/dev/kernel/FSKit/HeFS.h b/dev/kernel/FSKit/HeFS.h
index 27fe2838..ce9b9226 100644
--- a/dev/kernel/FSKit/HeFS.h
+++ b/dev/kernel/FSKit/HeFS.h
@@ -21,10 +21,11 @@
 #define kHeFSMagic "  HeFS"
 #define kHeFSMagicLen (8)
 
+#define kHeFSBlockLen (512U)
 #define kHeFSFileNameLen (256U)
 #define kHeFSPartNameLen (128U)
 
-#define kHeFSMinimumDiskSize (mib_cast(16))
+#define kHeFSMinimumDiskSize (gib_cast(1))
 
 #define kHeFSDefaultVoluneName u8"HeFS Volume"
 
@@ -36,6 +37,7 @@ struct HEFS_BOOT_NODE;
 struct HEFS_INDEX_NODE;
 struct HEFS_INDEX_NODE_DIRECTORY;
 struct HEFS_JOURNAL_NODE;
+struct HEFS_INODE_SLICE;
 
 enum : UInt8 {
   kHeFSHardDrive         = 0xC0,  // Hard Drive
@@ -123,16 +125,21 @@ struct PACKED HEFS_BOOT_NODE final {
   Kernel::UInt16 fDiskFlags;   /// @brief Flags of the disk. (read-only, read-write, etc).
   Kernel::UInt16
       fVID;  /// @brief Virtual Identification Number within an EPM disk. (0xFFFF if not used).
-  Kernel::UInt64 fStartIN;    /// @brief Reserved for future use.
-  Kernel::UInt64 fEndIN;      /// @brief Reserved for future use.
-  Kernel::UInt64 fReserved;   /// @brief Reserved for future use.
-  Kernel::UInt64 fReserved1;  /// @brief Reserved for future use.
+  Kernel::UInt64 fStartIN;     /// @brief Reserved for future use.
+  Kernel::UInt64 fEndIN;       /// @brief Reserved for future use.
+  Kernel::UInt64 fStartBlock;  /// @brief Reserved for future use.
+  Kernel::UInt64 fEndBlock;    /// @brief Reserved for future use.
   Kernel::Char   fPad[272];
 };
 
 inline constexpr Kernel::ATime kHeFSTimeInvalid = 0x0000000000000000;
 inline constexpr Kernel::ATime kHeFSTimeMax     = 0xFFFFFFFFFFFFFFFF - 1;
 
+struct PACKED HEFS_INODE_SLICE {
+  Kernel::UInt32 fBase;
+  Kernel::UInt32 fLength;
+};
+
 /// @brief HeFS index node.
 /// @details This structure is used to store the file information of a file.
 /// @note The index node is a special type of INode that contains the file information.
@@ -156,10 +163,7 @@ struct PACKED HEFS_INDEX_NODE final {
   /// @details Using an offset to ask fBase, and fLength to compute each slice's length.
   Kernel::UInt64 fOffsetSlices;
 
-  struct {
-    Kernel::UInt32 fBase;
-    Kernel::UInt32 fLength;
-  } fSlices[kHeFSSliceCount];  /// @brief block slice
+  HEFS_INODE_SLICE fSlices[kHeFSSliceCount];  /// @brief block slice
 
   Kernel::Char fPad[309];
 };
@@ -378,23 +382,22 @@ class HeFileSystemParser final {
                                     const Utf8Char* dir);
 
   _Output Bool CreateINode(_Input DriveTrait* drive, _Input const Int32 flags, const Utf8Char* dir,
-                           const Utf8Char* name);
+                           const Utf8Char* name, const UInt8 kind);
 
   _Output Bool DeleteINode(_Input DriveTrait* drive, _Input const Int32 flags, const Utf8Char* dir,
-                           const Utf8Char* name);
-
-  _Output Bool WriteINode(_Input DriveTrait* drive, VoidPtr block, SizeT block_sz,
-                          const Utf8Char* dir, const Utf8Char* name);
+                           const Utf8Char* name, const UInt8 kind);
 
-  _Output Bool ReadINode(_Input DriveTrait* drive, VoidPtr block, SizeT block_sz,
-                         const Utf8Char* dir, const Utf8Char* name);
+  _Output Bool INodeManip(_Input DriveTrait* drive, VoidPtr block, SizeT block_sz,
+                          const Utf8Char* dir, const UInt8 kind, const Utf8Char* name,
+                          const BOOL in);
 
  private:
-  _Output Bool INodeCtl_(_Input DriveTrait* drive, _Input const Int32 flags, const Utf8Char* dir,
-                         const Utf8Char* name, const BOOL delete_or_create);
+  _Output Bool INodeCtlManip(_Input DriveTrait* drive, _Input const Int32 flags,
+                             const Utf8Char* dir, const Utf8Char* name, const BOOL delete_or_create,
+                             const UInt8 kind);
 
-  _Output Bool INodeDirectoryCtl_(_Input DriveTrait* drive, _Input const Int32 flags,
-                                  const Utf8Char* dir, const BOOL delete_or_create);
+  _Output Bool INodeDirectoryCtlManip(_Input DriveTrait* drive, _Input const Int32 flags,
+                                      const Utf8Char* dir, const BOOL delete_or_create);
 };
 
 /// @brief Initialize HeFS inside the main disk.
-- 
cgit v1.2.3


From 4a80c0e7eaa36817f52e0f3cd6d8c8e07bf860dc Mon Sep 17 00:00:00 2001
From: Amlal El Mahrouss <amlal.elmahrouss@icloud.com>
Date: Tue, 6 May 2025 21:07:48 +0200
Subject: dev(kernel): Fix typo of `kHeFSDefaultVoluneName` to
 `kHeFSDefaultVolumeName` in HeFS.

---
 dev/kernel/FSKit/HeFS.h                    | 2 +-
 dev/kernel/src/FS/HeFS+FileSystemParser.cc | 2 +-
 docs/tex/hefs.tex                          | 2 +-
 tooling/hefs.h                             | 2 +-
 tooling/mkfs.hefs.cc                       | 4 ++--
 5 files changed, 6 insertions(+), 6 deletions(-)

(limited to 'dev/kernel/FSKit')

diff --git a/dev/kernel/FSKit/HeFS.h b/dev/kernel/FSKit/HeFS.h
index ce9b9226..f7e1d648 100644
--- a/dev/kernel/FSKit/HeFS.h
+++ b/dev/kernel/FSKit/HeFS.h
@@ -27,7 +27,7 @@
 
 #define kHeFSMinimumDiskSize (gib_cast(1))
 
-#define kHeFSDefaultVoluneName u8"HeFS Volume"
+#define kHeFSDefaultVolumeName u8"HeFS Volume"
 
 #define kHeFSINDStartOffset (sizeof(HEFS_INDEX_NODE_DIRECTORY) + sizeof(HEFS_BOOT_NODE))
 
diff --git a/dev/kernel/src/FS/HeFS+FileSystemParser.cc b/dev/kernel/src/FS/HeFS+FileSystemParser.cc
index 53e05c08..d3331710 100644
--- a/dev/kernel/src/FS/HeFS+FileSystemParser.cc
+++ b/dev/kernel/src/FS/HeFS+FileSystemParser.cc
@@ -1166,7 +1166,7 @@ Boolean fs_init_hefs(Void) {
 
   HeFileSystemParser parser;
 
-  parser.Format(&kMountPoint, kHeFSEncodingFlagsUTF8, kHeFSDefaultVoluneName);
+  parser.Format(&kMountPoint, kHeFSEncodingFlagsUTF8, kHeFSDefaultVolumeName);
 
   MUST_PASS(parser.CreateINode(&kMountPoint, kHeFSEncodingFlagsBinary | kHeFSFlagsReadOnly,
                                u8"/boot", u8"ジェット警察.txt", kHeFSFileKindRegular));
diff --git a/docs/tex/hefs.tex b/docs/tex/hefs.tex
index afafc472..dd857795 100644
--- a/docs/tex/hefs.tex
+++ b/docs/tex/hefs.tex
@@ -25,7 +25,7 @@ The High-throughput Extended File System (HeFS) is a custom filesystem tailored
 \texttt{kHeFSFileNameLen} & 256 characters \\
 \texttt{kHeFSPartNameLen} & 128 characters \\
 \texttt{kHeFSMinimumDiskSize} & 16 MiB \\
-\texttt{kHeFSDefaultVoluneName} & "HeFS Volume" \\
+\texttt{kHeFSDefaultVolumeName} & "HeFS Volume" \\
 \texttt{kHeFSINDStartOffset} & Offset after boot + dir nodes \\
 \texttt{kHeFSSearchAllStr} & "\*" (wildcard string) \\
 \hline
diff --git a/tooling/hefs.h b/tooling/hefs.h
index ded6cbef..f281e7a3 100644
--- a/tooling/hefs.h
+++ b/tooling/hefs.h
@@ -16,7 +16,7 @@
 #define kHeFSFileNameLen (256U)
 #define kHeFSPartNameLen (128U)
 
-#define kHeFSDefaultVoluneName u8"HeFS Volume"
+#define kHeFSDefaultVolumeName u8"HeFS Volume"
 
 namespace mkfs::hefs {
 
diff --git a/tooling/mkfs.hefs.cc b/tooling/mkfs.hefs.cc
index bc1f3d3c..5a706646 100644
--- a/tooling/mkfs.hefs.cc
+++ b/tooling/mkfs.hefs.cc
@@ -11,7 +11,7 @@
 
 static size_t        kDiskSize   = 1024 * 1024 * 1024 * 4UL;
 static uint16_t      kVersion    = kHeFSVersion;
-static std::u8string kLabel      = kHeFSDefaultVoluneName;
+static std::u8string kLabel      = kHeFSDefaultVolumeName;
 static size_t        kSectorSize = 512;
 
 int main(int argc, char** argv) {
@@ -43,7 +43,7 @@ int main(int argc, char** argv) {
   kSectorSize = std::strtol(mkfs::get_option<char>(args, "-s").data(), nullptr, 10);
   kLabel      = mkfs::get_option<char8_t>(args_wide, u8"-L");
 
-  if (kLabel.empty()) kLabel = kHeFSDefaultVoluneName;
+  if (kLabel.empty()) kLabel = kHeFSDefaultVolumeName;
 
   kDiskSize =
       std::strtol(mkfs::get_option<char>(args, "-S").data(), nullptr, 10) * 1024 * 1024 * 1024;
-- 
cgit v1.2.3


From a8782019a20f5487494e436f79b876b57f7229e1 Mon Sep 17 00:00:00 2001
From: Amlal <amlal@nekernel.org>
Date: Thu, 8 May 2025 08:48:57 +0200
Subject: feat(tooling): update HeFS headers, and better HeFS tooling.

Signed-off-by: Amlal <amlal@nekernel.org>
---
 dev/kernel/FSKit/HeFS.h                    |  8 +--
 dev/kernel/src/FS/HeFS+FileSystemParser.cc | 20 ++-----
 dev/modules/MBCI/MBCI.h                    |  5 +-
 tooling/hefs.h                             |  4 +-
 tooling/mkfs.hefs.cc                       | 92 ++++++++++++++++++------------
 5 files changed, 68 insertions(+), 61 deletions(-)

(limited to 'dev/kernel/FSKit')

diff --git a/dev/kernel/FSKit/HeFS.h b/dev/kernel/FSKit/HeFS.h
index f7e1d648..f5f42b47 100644
--- a/dev/kernel/FSKit/HeFS.h
+++ b/dev/kernel/FSKit/HeFS.h
@@ -125,10 +125,10 @@ struct PACKED HEFS_BOOT_NODE final {
   Kernel::UInt16 fDiskFlags;   /// @brief Flags of the disk. (read-only, read-write, etc).
   Kernel::UInt16
       fVID;  /// @brief Virtual Identification Number within an EPM disk. (0xFFFF if not used).
-  Kernel::UInt64 fStartIN;     /// @brief Reserved for future use.
-  Kernel::UInt64 fEndIN;       /// @brief Reserved for future use.
-  Kernel::UInt64 fStartBlock;  /// @brief Reserved for future use.
-  Kernel::UInt64 fEndBlock;    /// @brief Reserved for future use.
+  Kernel::UInt64 fStartIN;     /// @brief Start INodes range
+  Kernel::UInt64 fEndIN;       /// @brief End INodes range
+  Kernel::UInt64 fStartBlock;  /// @brief Start Blocks range
+  Kernel::UInt64 fEndBlock;    /// @brief End Blocks range
   Kernel::Char   fPad[272];
 };
 
diff --git a/dev/kernel/src/FS/HeFS+FileSystemParser.cc b/dev/kernel/src/FS/HeFS+FileSystemParser.cc
index 1cd7e61a..a324da2a 100644
--- a/dev/kernel/src/FS/HeFS+FileSystemParser.cc
+++ b/dev/kernel/src/FS/HeFS+FileSystemParser.cc
@@ -459,7 +459,7 @@ namespace Detail {
                                                                    const Utf8Char* dir_name,
                                                                    const Utf8Char* file_name,
                                                                    UInt8 kind, SizeT* cnt) {
-    if (mnt) {
+    if (mnt && cnt) {
       auto start = root->fStartIND;
 
       if (start > root->fEndIND) return nullptr;
@@ -514,7 +514,7 @@ namespace Detail {
         if (start > root->fEndIND) break;
       }
 
-      err_global_get()                 = kErrorSuccess;
+      err_global_get() = kErrorSuccess;
       delete dir;
 
       if (start_cnt == 0) {
@@ -535,7 +535,7 @@ namespace Detail {
   STATIC ATTRIBUTE(unused) _Output BOOL
       hefsi_update_in_status(HEFS_BOOT_NODE* root, DriveTrait* mnt, const Utf8Char* dir_name,
                              HEFS_INDEX_NODE* node, BOOL delete_or_create) {
-    if (!root) return NO;
+    if (!root || !mnt) return NO;
 
     auto start = root->fStartIND;
 
@@ -555,8 +555,6 @@ namespace Detail {
 
         mnt->fInput(mnt->fPacket);
 
-        kout8 << dir_name << u8"\r";
-
         (Void)(kout << hex_number(hefsi_hash_64(dir_name)) << kendl);
         (Void)(kout << hex_number(dir->fHashPath) << kendl);
 
@@ -621,12 +619,6 @@ namespace Detail {
 
               mnt->fInput(mnt->fPacket);
 
-              kout8 << u8"HashPath: ";
-              (Void)(kout << hex_number(tmp_node.fHashPath) << kendl);
-
-              kout8 << u8"HashPath: ";
-              (Void)(kout << hex_number(hash_file) << kendl);
-
               if (tmp_node.fHashPath != hash_file) {
                 continue;
               }
@@ -690,7 +682,7 @@ namespace Detail {
       auto start = root->fStartIND;
 
       while (YES) {
-        if (start == 0 || start > root->fEndIND) break;
+        if (start == 0UL || start > root->fEndIND) break;
 
         mnt->fPacket.fPacketLba     = start;
         mnt->fPacket.fPacketSize    = sizeof(HEFS_INDEX_NODE_DIRECTORY);
@@ -714,10 +706,10 @@ namespace Detail {
           mnt->fOutput(mnt->fPacket);
         }
 
-        if (dir->fColor == kHeFSBlack && dir->fChild != 0) {
+        if (dir->fColor == kHeFSBlack && dir->fChild != 0UL) {
           dir->fColor = kHeFSRed;
           hefsi_rotate_tree(start, mnt);
-        } else if (dir->fColor == kHeFSBlack && dir->fChild == 0) {
+        } else if (dir->fColor == kHeFSBlack && dir->fChild == 0UL) {
           dir->fColor = kHeFSBlack;
 
           mnt->fPacket.fPacketLba     = start;
diff --git a/dev/modules/MBCI/MBCI.h b/dev/modules/MBCI/MBCI.h
index 37f802ec..99ecf802 100644
--- a/dev/modules/MBCI/MBCI.h
+++ b/dev/modules/MBCI/MBCI.h
@@ -100,12 +100,11 @@ typedef UInt32 MBCIAuthKeyType;
 inline BOOL busi_test_mmio(_Input struct IMBCIHost* host, _Input const UInt32 test) {
   host->MMIOTest = test;
   UInt16 timeout = 0UL;
-  
+
   while (host->MMIOTest == test) {
     ++timeout;
 
-    if (timeout > 0x1000)
-      return NO;
+    if (timeout > 0x1000) return NO;
   }
 
   return host->MMIOTest == 0;
diff --git a/tooling/hefs.h b/tooling/hefs.h
index f281e7a3..68e0f906 100644
--- a/tooling/hefs.h
+++ b/tooling/hefs.h
@@ -102,8 +102,8 @@ struct __attribute__((packed)) BootNode {
   std::uint16_t vid{};
   std::uint64_t startIN{};
   std::uint64_t endIN{};
-  std::uint64_t reserved3{};
-  std::uint64_t reserved4{};
+  std::uint64_t startBlock{};
+  std::uint64_t endBlock{};
   char          pad[272]{};
 };
 }  // namespace mkfs::hefs
diff --git a/tooling/mkfs.hefs.cc b/tooling/mkfs.hefs.cc
index 5a706646..2ddc7484 100644
--- a/tooling/mkfs.hefs.cc
+++ b/tooling/mkfs.hefs.cc
@@ -16,9 +16,10 @@ static size_t        kSectorSize = 512;
 
 int main(int argc, char** argv) {
   if (argc < 2) {
-    mkfs::console_out() << "hefs: Usage: mkfs.hefs -L <label> -s <sector_size> -p <part_start> -e "
-                        << "<part_end> -S <disk_size> -o <output_device>" << std::endl;
-
+    mkfs::console_out() << "hefs: usage: mkfs.hefs -L <label> -s <sector_size> -b <ind_start> -e "
+                        << "<ind_end> -bs <block_start> -be <block_end> -is <in_start> -ie <in_end> "
+                           "-S <disk_size> -o <output_device>"
+                        << "\n";
     return EXIT_FAILURE;
   }
 
@@ -38,68 +39,83 @@ int main(int argc, char** argv) {
     args_wide += u8" ";
   }
 
-  auto output_device = mkfs::get_option<char>(args, "-o");
+  auto output_path = mkfs::get_option<char>(args, "-o");
 
   kSectorSize = std::strtol(mkfs::get_option<char>(args, "-s").data(), nullptr, 10);
   kLabel      = mkfs::get_option<char8_t>(args_wide, u8"-L");
 
+  if (!kSectorSize) {
+    mkfs::console_out() << "hefs: error: Sector size size is zero.\n";
+    return EXIT_FAILURE;
+  }
+
   if (kLabel.empty()) kLabel = kHeFSDefaultVolumeName;
 
   kDiskSize =
       std::strtol(mkfs::get_option<char>(args, "-S").data(), nullptr, 10) * 1024 * 1024 * 1024;
 
-  if (kDiskSize == 0) {
-    mkfs::console_out() << "hefs: Error: Unable to deduce future disk size for output_device: "
-                        << output_device << std::endl;
+  if (!kDiskSize) {
+    mkfs::console_out() << "hefs: error: Disk size is zero.\n";
     return EXIT_FAILURE;
   }
 
   // Open the output_device
-  std::ofstream filesystem(output_device, std::ios::binary);
+  std::ofstream output_device(output_path, std::ios::binary);
 
-  if (!filesystem.good()) {
-    mkfs::console_out() << "hefs: Info: Unable to open output_device: " << output_device
-                        << std::endl;
+  if (!output_device.good()) {
+    mkfs::console_out() << "hefs: error: Unable to open output_device: " << output_path
+                        << "\n";
     return EXIT_FAILURE;
   }
 
   // create a boot node, and then allocate a index node directory tree.
-  mkfs::hefs::BootNode bootNode{{}, {}, 0, 0, 0, 0, 0, 0, 0, 0};
+  mkfs::hefs::BootNode boot_node{{}, {}, 0, 0, 0, 0, 0, 0, 0, 0};
 
-  auto start_ind = std::strtol(mkfs::get_option<char>(args, "-p").data(), nullptr, 10);
+  auto start_ind = std::strtol(mkfs::get_option<char>(args, "-b").data(), nullptr, 16);
 
   start_ind += sizeof(mkfs::hefs::BootNode);
 
-  auto end_ind = std::strtol(mkfs::get_option<char>(args, "-e").data(), nullptr, 10);
-
-  bootNode.version    = kVersion;
-  bootNode.diskKind   = mkfs::hefs::kHeFSHardDrive;
-  bootNode.encoding   = mkfs::hefs::kHeFSEncodingFlagsUTF8;
-  bootNode.diskSize   = kDiskSize;
-  bootNode.sectorSize = kSectorSize;
-  bootNode.startIND   = start_ind;
-  bootNode.endIND     = end_ind;
-  bootNode.indCount   = 0UL;
-  bootNode.diskStatus = mkfs::hefs::kHeFSStatusUnlocked;
-
-  std::memcpy(bootNode.magic, kHeFSMagic, kHeFSMagicLen - 1);
-  std::memcpy(bootNode.volumeName, kLabel.data(), kLabel.size() * sizeof(char16_t));
-
-  filesystem.seekp(std::strtol(mkfs::get_option<char>(args, "-p").data(), nullptr, 10));
-  filesystem.write(reinterpret_cast<const char*>(&bootNode), sizeof(mkfs::hefs::BootNode));
-
-  if (!filesystem.good()) {
-    mkfs::console_out() << "hefs: Error: Unable to write FS to output_device: " << output_device
-                        << std::endl;
+  auto end_ind = std::strtol(mkfs::get_option<char>(args, "-e").data(), nullptr, 16);
+
+  auto start_block = std::strtol(mkfs::get_option<char>(args, "-bs").data(), nullptr, 16);
+  auto end_block   = std::strtol(mkfs::get_option<char>(args, "-be").data(), nullptr, 16);
+
+  auto start_in = std::strtol(mkfs::get_option<char>(args, "-is").data(), nullptr, 16);
+  auto end_in   = std::strtol(mkfs::get_option<char>(args, "-ie").data(), nullptr, 16);
+
+  boot_node.version    = kVersion;
+  boot_node.diskKind   = mkfs::hefs::kHeFSHardDrive;
+  boot_node.encoding   = mkfs::hefs::kHeFSEncodingFlagsUTF8;
+  boot_node.diskSize   = kDiskSize;
+  boot_node.sectorSize = kSectorSize;
+  boot_node.startIND   = start_ind;
+  boot_node.endIND     = end_ind;
+  boot_node.startIN    = start_in;
+  boot_node.endIN      = end_in;
+  boot_node.startBlock = start_block;
+  boot_node.endBlock   = end_block;
+  boot_node.indCount   = 0UL;
+  boot_node.diskStatus = mkfs::hefs::kHeFSStatusUnlocked;
+
+  std::memcpy(boot_node.magic, kHeFSMagic, kHeFSMagicLen - 1);
+  std::memcpy(boot_node.volumeName, kLabel.data(), kLabel.size() * sizeof(char16_t));
+
+  output_device.seekp(std::strtol(mkfs::get_option<char>(args, "-b").data(), nullptr, 16));
+  output_device.write(reinterpret_cast<const char*>(&boot_node), sizeof(mkfs::hefs::BootNode));
+
+  if (!output_device.good()) {
+    mkfs::console_out() << "hefs: error: Unable to write filesystem to output_device: "
+                        << output_path << "\n";
     return EXIT_FAILURE;
   }
 
-  filesystem.seekp(bootNode.startIND);
+  output_device.seekp(boot_node.startIND);
 
-  filesystem.flush();
-  filesystem.close();
+  output_device.flush();
+  output_device.close();
 
-  mkfs::console_out() << "hefs: Info: Wrote FS to output_device: " << output_device << std::endl;
+  mkfs::console_out() << "hefs: info: Wrote filesystem to output_device: " << output_path
+                      << "\n";
 
   return EXIT_SUCCESS;
 }
\ No newline at end of file
-- 
cgit v1.2.3


From 902bafa5dc8c3ac5fcbf13a5af73e016e9c64685 Mon Sep 17 00:00:00 2001
From: Amlal <amlal@nekernel.org>
Date: Thu, 8 May 2025 10:17:30 +0200
Subject: meta(kernel): saving changes to avoid loss.

Signed-off-by: Amlal <amlal@nekernel.org>
---
 dev/generic_kits/BenchKit/Chrono.h              |  16 +++
 dev/kernel/FSKit/HeFS.h                         | 172 +++++++++++++-----------
 dev/kernel/HALKit/AMD64/Storage/AHCI+Generic.cc |   8 +-
 dev/kernel/KernelKit/KernelProcessScheduler.h   |   7 -
 dev/kernel/KernelKit/KernelTaskScheduler.h      |  15 +++
 dev/kernel/KernelKit/ProcessScheduler.h         |   2 +-
 dev/kernel/KernelKit/UserProcessScheduler.h     |   2 +-
 dev/kernel/src/BinaryMutex.cc                   |   2 +-
 dev/kernel/src/DriveMgr+IO.cc                   |  22 +--
 dev/kernel/src/FS/HeFS+FileSystemParser.cc      |  23 +++-
 dev/kernel/src/KernelProcessScheduler.cc        |  18 ---
 dev/kernel/src/KernelTaskScheduler.cc           |  18 +++
 docs/tex/hefs.tex                               |   2 +-
 public/tools/mgmt.hefs/.keep                    |   0
 public/tools/mgmt.hefs/mgmt.hefs.json           |  19 +++
 public/tools/mgmt.hefs/src/.keep                |   0
 public/tools/mgmt.hefs/vendor/.keep             |   0
 public/tools/mgmt/.keep                         |   0
 public/tools/mgmt/mgmt.json                     |  19 +++
 public/tools/mgmt/src/.keep                     |   0
 public/tools/mgmt/src/CommandLine.cc            |   3 +
 public/tools/mgmt/vendor/.keep                  |   0
 tooling/mk_fwrk.py                              |  15 ++-
 23 files changed, 232 insertions(+), 131 deletions(-)
 create mode 100644 dev/generic_kits/BenchKit/Chrono.h
 delete mode 100644 dev/kernel/KernelKit/KernelProcessScheduler.h
 create mode 100644 dev/kernel/KernelKit/KernelTaskScheduler.h
 delete mode 100644 dev/kernel/src/KernelProcessScheduler.cc
 create mode 100644 dev/kernel/src/KernelTaskScheduler.cc
 create mode 100644 public/tools/mgmt.hefs/.keep
 create mode 100644 public/tools/mgmt.hefs/mgmt.hefs.json
 create mode 100644 public/tools/mgmt.hefs/src/.keep
 create mode 100644 public/tools/mgmt.hefs/vendor/.keep
 create mode 100644 public/tools/mgmt/.keep
 create mode 100644 public/tools/mgmt/mgmt.json
 create mode 100644 public/tools/mgmt/src/.keep
 create mode 100644 public/tools/mgmt/src/CommandLine.cc
 create mode 100644 public/tools/mgmt/vendor/.keep

(limited to 'dev/kernel/FSKit')

diff --git a/dev/generic_kits/BenchKit/Chrono.h b/dev/generic_kits/BenchKit/Chrono.h
new file mode 100644
index 00000000..98f3d980
--- /dev/null
+++ b/dev/generic_kits/BenchKit/Chrono.h
@@ -0,0 +1,16 @@
+/* -------------------------------------------
+
+Copyright (C) 2025, Amlal El Mahrouss, all rights reserved.
+
+------------------------------------------- */
+
+#ifndef BENCHKIT_CHRONO_H
+#define BENCHKIT_CHRONO_H
+
+#include <NewKit/Defines.h>
+
+namespace Kernel {
+class ChronoInterface;
+}  // namespace Kernel
+
+#endif  // BENCHKIT_CHRONO_H
diff --git a/dev/kernel/FSKit/HeFS.h b/dev/kernel/FSKit/HeFS.h
index f5f42b47..f6f2d1dd 100644
--- a/dev/kernel/FSKit/HeFS.h
+++ b/dev/kernel/FSKit/HeFS.h
@@ -37,7 +37,7 @@ struct HEFS_BOOT_NODE;
 struct HEFS_INDEX_NODE;
 struct HEFS_INDEX_NODE_DIRECTORY;
 struct HEFS_JOURNAL_NODE;
-struct HEFS_INODE_SLICE;
+struct HEFS_SLICE_NODE;
 
 enum : UInt8 {
   kHeFSHardDrive         = 0xC0,  // Hard Drive
@@ -100,44 +100,57 @@ namespace Kernel {
 /// @brief Access time type.
 /// @details Used to keep track of the INode, INodeDir allocation status.
 typedef UInt64 ATime;
-}  // namespace Kernel
 
 /// @brief HeFS Boot node.
 /// @details Acts like a superblock, it contains the information about the filesystem.
 /// @note The boot node is the first block of the filesystem.
 struct PACKED HEFS_BOOT_NODE final {
-  Kernel::Char     fMagic[kHeFSMagicLen];       /// @brief Magic number of the filesystem.
-  Kernel::Utf8Char fVolName[kHeFSPartNameLen];  /// @brief Volume name.
-  Kernel::UInt32   fVersion;                    /// @brief Version of the filesystem.
-  Kernel::UInt64   fBadSectors;                 /// @brief Number of bad sectors in the filesystem.
-  Kernel::UInt64   fSectorCount;                /// @brief Number of sectors in the filesystem.
-  Kernel::UInt64   fSectorSize;                 /// @brief Size of the sector.
-  Kernel::UInt32   fChecksum;                   /// @brief Checksum of the boot node.
-  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 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).
-  Kernel::UInt16 fDiskFlags;   /// @brief Flags of the disk. (read-only, read-write, etc).
-  Kernel::UInt16
-      fVID;  /// @brief Virtual Identification Number within an EPM disk. (0xFFFF if not used).
-  Kernel::UInt64 fStartIN;     /// @brief Start INodes range
-  Kernel::UInt64 fEndIN;       /// @brief End INodes range
-  Kernel::UInt64 fStartBlock;  /// @brief Start Blocks range
-  Kernel::UInt64 fEndBlock;    /// @brief End Blocks range
-  Kernel::Char   fPad[272];
+  Char     fMagic[kHeFSMagicLen];       /// @brief Magic number of the filesystem.
+  Utf8Char fVolName[kHeFSPartNameLen];  /// @brief Volume name.
+  UInt32   fVersion;                    /// @brief Version of the filesystem.
+  UInt64   fBadSectors;                 /// @brief Number of bad sectors in the filesystem.
+  UInt64   fSectorCount;                /// @brief Number of sectors in the filesystem.
+  UInt64   fSectorSize;                 /// @brief Size of the sector.
+  UInt32   fChecksum;                   /// @brief Checksum of the boot node.
+  UInt8    fDiskKind;  /// @brief Kind of the drive. (Hard Drive, Solid State Drive, Optical
+                       /// Drive, etc).
+  UInt8  fEncoding;    /// @brief Encoding of the filesystem. (UTF-8, UTF-16, etc).
+  UInt64 fStartIND;    /// @brief Start of the INode directory tree.
+  UInt64 fEndIND;      /// @brief End of the INode directory tree.
+  UInt64 fINDCount;    /// @brief Number of leafs in the INode tree.
+  UInt64 fDiskSize;    /// @brief Size of the disk. (Could be a virtual size, that is not the
+                       /// real size of the disk.)
+  UInt16 fDiskStatus;  /// @brief Status of the disk. (locked, unlocked, error, invalid).
+  UInt16 fDiskFlags;   /// @brief Flags of the disk. (read-only, read-write, etc).
+  UInt16 fVID;  /// @brief Virtual Identification Number within an EPM disk. (0xFFFF if not used).
+  UInt64 fStartIN;     /// @brief Start INodes range
+  UInt64 fEndIN;       /// @brief End INodes range
+  UInt64 fStartBlock;  /// @brief Start Blocks range
+  UInt64 fEndBlock;    /// @brief End Blocks range
+  UInt64 fJournalLBA;  /// @brief Boot Node's COW journal LBA.
+  Char   fPad[264];
 };
 
-inline constexpr Kernel::ATime kHeFSTimeInvalid = 0x0000000000000000;
-inline constexpr Kernel::ATime kHeFSTimeMax     = 0xFFFFFFFFFFFFFFFF - 1;
+inline constexpr ATime kHeFSTimeInvalid = 0x0000000000000000;
+inline constexpr ATime kHeFSTimeMax     = 0xFFFFFFFFFFFFFFFF - 1;
+
+/// @brief INode Slice structure, organized like a range container.
+struct PACKED HEFS_SLICE_NODE {
+  UInt32 fBase;
+  UInt32 fLength;
+};
 
-struct PACKED HEFS_INODE_SLICE {
-  Kernel::UInt32 fBase;
-  Kernel::UInt32 fLength;
+/// @brief Journal Node structure
+/// @param fHashPath target hash path
+/// @param fStatus target status
+/// @param fCopyElem copy of element
+/// @param fCopyKind kind of element
+struct PACKED HEFS_JOURNAL_NODE {
+  UInt64 fHashPath;
+  UInt64 fStatus;
+  UInt64 fCopyElem;
+  UInt8  fCopyKind;
+  UInt8  fPad[487];
 };
 
 /// @brief HeFS index node.
@@ -145,27 +158,27 @@ struct PACKED HEFS_INODE_SLICE {
 /// @note The index node is a special type of INode that contains the file information.
 /// @note The index node is used to store the file information of a file.
 struct PACKED HEFS_INDEX_NODE final {
-  Kernel::UInt64 fHashPath;  /// @brief File name.
-  Kernel::UInt32 fFlags;     /// @brief File flags.
-  Kernel::UInt16 fKind;  /// @brief File kind. (Regular, Directory, Block, Character, FIFO, Socket,
-                         /// Symbolic Link, Unknown).
-  Kernel::UInt32 fSize;  /// @brief File size.
-  Kernel::UInt32 fChecksum;  /// @brief Checksum.
+  UInt64 fHashPath;  /// @brief File name.
+  UInt32 fFlags;     /// @brief File flags.
+  UInt16 fKind;      /// @brief File kind. (Regular, Directory, Block, Character, FIFO, Socket,
+                     /// Symbolic Link, Unknown).
+  UInt32 fSize;      /// @brief File size.
+  UInt32 fChecksum;  /// @brief Checksum.
 
-  Kernel::Boolean fSymLink;  /// @brief Is this a symbolic link? (if yes, the fName is the path to
-                             /// the file and blocklinkstart and end contains it's inodes.)
+  Boolean fSymLink;  /// @brief Is this a symbolic link? (if yes, the fName is the path to
+                     /// the file and blocklinkstart and end contains it's inodes.)
 
-  Kernel::ATime  fCreated, fAccessed, fModified, fDeleted;  /// @brief File timestamps.
-  Kernel::UInt32 fUID, fGID;  /// @brief User ID and Group ID of the file.
-  Kernel::UInt32 fMode;       /// @brief File mode. (read, write, execute, etc).
+  ATime  fCreated, fAccessed, fModified, fDeleted;  /// @brief File timestamps.
+  UInt32 fUID, fGID;                                /// @brief User ID and Group ID of the file.
+  UInt32 fMode;  /// @brief File mode. (read, write, execute, etc).
 
   /// @brief Extents system by using blocks
   /// @details Using an offset to ask fBase, and fLength to compute each slice's length.
-  Kernel::UInt64 fOffsetSlices;
+  UInt64 fOffsetSlices;
 
-  HEFS_INODE_SLICE fSlices[kHeFSSliceCount];  /// @brief block slice
+  HEFS_SLICE_NODE fSlices[kHeFSSliceCount];  /// @brief block slice
 
-  Kernel::Char fPad[309];
+  Char fPad[309];
 };
 
 enum {
@@ -179,69 +192,70 @@ 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 path as FNV hash.
+  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,
-                          /// Symbolic Link, Unknown).
-  Kernel::UInt32 fEntryCount;  /// @brief Entry Count of this directory inode.
-  Kernel::UInt32 fChecksum;    /// @brief Checksum of the file, index node checksum.
+  UInt32 fFlags;       /// @brief File flags.
+  UInt16 fKind;        /// @brief File kind. (Regular, Directory, Block, Character, FIFO, Socket,
+                       /// Symbolic Link, Unknown).
+  UInt32 fEntryCount;  /// @brief Entry Count of this directory inode.
+  UInt32 fChecksum;    /// @brief Checksum of the file, index node checksum.
 
-  Kernel::ATime fCreated, fAccessed, fModified,
-      fDeleted;               /// @brief File timestamps and allocation status.
-  Kernel::UInt32 fUID, fGID;  /// @brief User ID and Group ID of the file.
-  Kernel::UInt32 fMode;       /// @brief File mode. (read, write, execute, etc).
+  ATime fCreated, fAccessed, fModified,
+      fDeleted;       /// @brief File timestamps and allocation status.
+  UInt32 fUID, fGID;  /// @brief User ID and Group ID of the file.
+  UInt32 fMode;       /// @brief File mode. (read, write, execute, etc).
 
   /// @note These slices are organized as:
   /// [0] = OFFSET
   /// [1] = SIZE
   /// @note Thus the += 2 when iterating over them.
-  Kernel::UInt64 fINSlices[kHeFSSliceCount];  /// @brief Start of the index node.
+  UInt64 fINSlices[kHeFSSliceCount];  /// @brief Start of the index node.
 
-  Kernel::UInt8 fColor;                         /// @brief Color of the node. (Red or Black).
-  Kernel::Lba   fNext, fPrev, fChild, fParent;  /// @brief Red-black tree pointers.
+  UInt8 fColor;                         /// @brief Color of the node. (Red or Black).
+  Lba   fNext, fPrev, fChild, fParent;  /// @brief Red-black tree pointers.
 
-  Kernel::Char fPad[285];
+  Char fPad[285];
 };
+}  // namespace Kernel
 
 namespace Kernel::Detail {
-/// @brief HeFS get year from Kernel::ATime.
-/// @param raw_atime the raw Kernel::ATime value.
+/// @brief HeFS get year from ATime.
+/// @param raw_atime the raw ATime value.
 /// @return the year value.
-/// @note The year is stored in the upper 32 bits of the Kernel::ATime value.
-inline UInt32 hefs_year_get(Kernel::ATime raw_atime) noexcept {
+/// @note The year is stored in the upper 32 bits of the ATime value.
+inline UInt32 hefs_year_get(ATime raw_atime) noexcept {
   return (raw_atime) >> 32;
 }
 
-/// @brief HeFS get month from Kernel::ATime.
-/// @param raw_atime the raw Kernel::ATime value.
+/// @brief HeFS get month from ATime.
+/// @param raw_atime the raw ATime value.
 /// @return the month value.
-/// @note The month is stored in the upper 24 bits of the Kernel::ATime value.
-inline UInt32 hefs_month_get(Kernel::ATime raw_atime) noexcept {
+/// @note The month is stored in the upper 24 bits of the ATime value.
+inline UInt32 hefs_month_get(ATime raw_atime) noexcept {
   return (raw_atime) >> 24;
 }
 
-/// @brief HeFS get day from Kernel::ATime.
-/// @param raw_atime the raw Kernel::ATime value.
+/// @brief HeFS get day from ATime.
+/// @param raw_atime the raw ATime value.
 /// @return the day value.
-/// @note The day is stored in the upper 16 bits of the Kernel::ATime value.
-inline UInt32 hefs_day_get(Kernel::ATime raw_atime) noexcept {
+/// @note The day is stored in the upper 16 bits of the ATime value.
+inline UInt32 hefs_day_get(ATime raw_atime) noexcept {
   return (raw_atime) >> 16;
 }
 
-/// @brief HeFS get hour from Kernel::ATime.
-/// @param raw_atime the raw Kernel::ATime value.
+/// @brief HeFS get hour from ATime.
+/// @param raw_atime the raw ATime value.
 /// @return the hour value.
-/// @note The hour is stored in the upper 8 bits of the Kernel::ATime value.
-inline UInt32 hefs_hour_get(Kernel::ATime raw_atime) noexcept {
+/// @note The hour is stored in the upper 8 bits of the ATime value.
+inline UInt32 hefs_hour_get(ATime raw_atime) noexcept {
   return (raw_atime) >> 8;
 }
 
-/// @brief HeFS get minute from Kernel::ATime.
-/// @param raw_atime the raw Kernel::ATime value.
+/// @brief HeFS get minute from ATime.
+/// @param raw_atime the raw ATime value.
 /// @return the minute value.
-/// @note The minute is stored in the lower 8 bits of the Kernel::ATime value.
-inline UInt32 hefs_minute_get(Kernel::ATime raw_atime) noexcept {
+/// @note The minute is stored in the lower 8 bits of the ATime value.
+inline UInt32 hefs_minute_get(ATime raw_atime) noexcept {
   return (raw_atime) & 0xFF;
 }
 
diff --git a/dev/kernel/HALKit/AMD64/Storage/AHCI+Generic.cc b/dev/kernel/HALKit/AMD64/Storage/AHCI+Generic.cc
index 4b0270ab..2b7aec14 100644
--- a/dev/kernel/HALKit/AMD64/Storage/AHCI+Generic.cc
+++ b/dev/kernel/HALKit/AMD64/Storage/AHCI+Generic.cc
@@ -71,6 +71,10 @@ STATIC Int32 drv_find_cmd_slot_ahci(HbaPort* port) noexcept;
 
 STATIC Void drv_compute_disk_ahci() noexcept;
 
+STATIC SizeT drv_get_size_ahci();
+
+STATIC SizeT drv_get_sector_count_ahci();
+
 /***********************************************************************************/
 /// @brief Identify device and read LBA info, Disk OEM vendor.
 /***********************************************************************************/
@@ -292,13 +296,13 @@ STATIC Void drv_std_input_output_ahci(UInt64 lba, UInt8* buffer, SizeT sector_sz
   @brief Gets the number of sectors inside the drive.
   @return Sector size in bytes.
  */
-SizeT drv_get_sector_count_ahci() {
+STATIC SizeT drv_get_sector_count_ahci() {
   return kSATASectorCount;
 }
 
 /// @brief Get the drive size.
 /// @return Disk size in bytes.
-SizeT drv_get_size_ahci() {
+STATIC SizeT drv_get_size_ahci() {
   return drv_std_get_sector_count() * kAHCISectorSize;
 }
 
diff --git a/dev/kernel/KernelKit/KernelProcessScheduler.h b/dev/kernel/KernelKit/KernelProcessScheduler.h
deleted file mode 100644
index 24d40a36..00000000
--- a/dev/kernel/KernelKit/KernelProcessScheduler.h
+++ /dev/null
@@ -1,7 +0,0 @@
-/* -------------------------------------------
-
-  Copyright (C) 2025, Amlal El Mahrouss, all rights reserved.
-
-------------------------------------------- */
-
-#pragma once
\ No newline at end of file
diff --git a/dev/kernel/KernelKit/KernelTaskScheduler.h b/dev/kernel/KernelKit/KernelTaskScheduler.h
new file mode 100644
index 00000000..ca10003f
--- /dev/null
+++ b/dev/kernel/KernelKit/KernelTaskScheduler.h
@@ -0,0 +1,15 @@
+/* -------------------------------------------
+
+  Copyright (C) 2025, Amlal El Mahrouss, all rights reserved.
+
+------------------------------------------- */
+
+#pragma once
+
+/// @file KernelTaskScheduler.h
+/// @brief Kernel Task Scheduler header file.
+/// @author Amlal El Mahrouss (amlal@nekernel.org)
+
+#include <ArchKit/ArchKit.h>
+#include <KernelKit/CoreProcessScheduler.h>
+#include <KernelKit/LockDelegate.h>
\ No newline at end of file
diff --git a/dev/kernel/KernelKit/ProcessScheduler.h b/dev/kernel/KernelKit/ProcessScheduler.h
index 6da176b3..6bdc8b1c 100644
--- a/dev/kernel/KernelKit/ProcessScheduler.h
+++ b/dev/kernel/KernelKit/ProcessScheduler.h
@@ -6,5 +6,5 @@
 
 #pragma once
 
-#include <KernelKit/KernelProcessScheduler.h>
+#include <KernelKit/KernelTaskScheduler.h>
 #include <KernelKit/UserProcessScheduler.h>
\ No newline at end of file
diff --git a/dev/kernel/KernelKit/UserProcessScheduler.h b/dev/kernel/KernelKit/UserProcessScheduler.h
index 1e8719ca..b64e5ce1 100644
--- a/dev/kernel/KernelKit/UserProcessScheduler.h
+++ b/dev/kernel/KernelKit/UserProcessScheduler.h
@@ -8,7 +8,7 @@
 #define INC_PROCESS_SCHEDULER_H
 
 /// @file UserProcessScheduler.h
-/// @brief User USER_PROCESS scheduler code and definitions.
+/// @brief User Process Scheduler header file.
 /// @author Amlal El Mahrouss (amlal@nekernel.org)
 
 #include <ArchKit/ArchKit.h>
diff --git a/dev/kernel/src/BinaryMutex.cc b/dev/kernel/src/BinaryMutex.cc
index 8bf1432e..bbf7a477 100644
--- a/dev/kernel/src/BinaryMutex.cc
+++ b/dev/kernel/src/BinaryMutex.cc
@@ -12,7 +12,7 @@ namespace Kernel {
 /// @brief Unlocks the binary mutex.
 /***********************************************************************************/
 Bool BinaryMutex::Unlock() noexcept {
-  if (fLockingProcess) {
+  if (fLockingProcess.Status == ProcessStatusKind::kRunning) {
     fLockingProcess        = USER_PROCESS();
     fLockingProcess.Status = ProcessStatusKind::kFrozen;
 
diff --git a/dev/kernel/src/DriveMgr+IO.cc b/dev/kernel/src/DriveMgr+IO.cc
index 4c9b20e0..9137c91e 100644
--- a/dev/kernel/src/DriveMgr+IO.cc
+++ b/dev/kernel/src/DriveMgr+IO.cc
@@ -17,10 +17,10 @@
  *
  *************************************************************/
 
-/// Useful macros.
+/// Useful macros regarding the IFS.
 
-#define rtl_nefs_write(DRV, TRAITS, MP) (MP->DRV()).fOutput(TRAITS)
-#define rtl_nefs_read(DRV, TRAITS, MP) (MP->DRV()).fInput(TRAITS)
+#define fsi_ifs_write(DRV, TRAITS, MP) (MP->DRV()).fOutput(TRAITS)
+#define fsi_ifs_read(DRV, TRAITS, MP) (MP->DRV()).fInput(TRAITS)
 
 namespace Kernel {
 /// @brief Read from newfs disk.
@@ -35,19 +35,19 @@ Int32 fs_ifs_read(MountpointInterface* Mnt, DriveTrait& DrvTrait, Int32 DrvIndex
 
   switch (DrvIndex) {
     case MountpointInterface::kDriveIndexA: {
-      rtl_nefs_read(A, DrvTrait.fPacket, Mnt);
+      fsi_ifs_read(A, DrvTrait.fPacket, Mnt);
       break;
     }
     case MountpointInterface::kDriveIndexB: {
-      rtl_nefs_read(B, DrvTrait.fPacket, Mnt);
+      fsi_ifs_read(B, DrvTrait.fPacket, Mnt);
       break;
     }
     case MountpointInterface::kDriveIndexC: {
-      rtl_nefs_read(C, DrvTrait.fPacket, Mnt);
+      fsi_ifs_read(C, DrvTrait.fPacket, Mnt);
       break;
     }
     case MountpointInterface::kDriveIndexD: {
-      rtl_nefs_read(D, DrvTrait.fPacket, Mnt);
+      fsi_ifs_read(D, DrvTrait.fPacket, Mnt);
       break;
     }
   }
@@ -67,19 +67,19 @@ Int32 fs_ifs_write(MountpointInterface* Mnt, DriveTrait& DrvTrait, Int32 DrvInde
 
   switch (DrvIndex) {
     case MountpointInterface::kDriveIndexA: {
-      rtl_nefs_write(A, DrvTrait.fPacket, Mnt);
+      fsi_ifs_write(A, DrvTrait.fPacket, Mnt);
       break;
     }
     case MountpointInterface::kDriveIndexB: {
-      rtl_nefs_write(B, DrvTrait.fPacket, Mnt);
+      fsi_ifs_write(B, DrvTrait.fPacket, Mnt);
       break;
     }
     case MountpointInterface::kDriveIndexC: {
-      rtl_nefs_write(C, DrvTrait.fPacket, Mnt);
+      fsi_ifs_write(C, DrvTrait.fPacket, Mnt);
       break;
     }
     case MountpointInterface::kDriveIndexD: {
-      rtl_nefs_write(D, DrvTrait.fPacket, Mnt);
+      fsi_ifs_write(D, DrvTrait.fPacket, Mnt);
       break;
     }
   }
diff --git a/dev/kernel/src/FS/HeFS+FileSystemParser.cc b/dev/kernel/src/FS/HeFS+FileSystemParser.cc
index a324da2a..d66c4a53 100644
--- a/dev/kernel/src/FS/HeFS+FileSystemParser.cc
+++ b/dev/kernel/src/FS/HeFS+FileSystemParser.cc
@@ -422,6 +422,8 @@ namespace Detail {
           else
             --root->fINDCount;
 
+          root->fChecksum = ke_calculate_crc32((Char*) root, sizeof(HEFS_BOOT_NODE));
+
           mnt->fPacket.fPacketLba     = mnt->fLbaStart;
           mnt->fPacket.fPacketSize    = sizeof(HEFS_BOOT_NODE);
           mnt->fPacket.fPacketContent = root;
@@ -584,9 +586,9 @@ namespace Detail {
               SizeT cnt = 0ULL;
 
               while (cnt < kHeFSSliceCount) {
-                HEFS_INODE_SLICE& slice = node->fSlices[cnt];
-                slice.fBase             = offset;
-                slice.fLength           = kHeFSBlockLen;
+                HEFS_SLICE_NODE& slice = node->fSlices[cnt];
+                slice.fBase            = offset;
+                slice.fLength          = kHeFSBlockLen;
                 offset += kHeFSBlockLen;
 
                 ++cnt;
@@ -601,10 +603,14 @@ namespace Detail {
               root->fStartIN += sizeof(HEFS_INDEX_NODE);
               root->fStartBlock += (kHeFSSliceCount * kHeFSBlockLen);
 
+              root->fChecksum = ke_calculate_crc32((Char*) root, sizeof(HEFS_BOOT_NODE));
+
               mnt->fPacket.fPacketLba     = mnt->fLbaStart;
               mnt->fPacket.fPacketSize    = sizeof(HEFS_BOOT_NODE);
               mnt->fPacket.fPacketContent = root;
 
+              mnt->fOutput(mnt->fPacket);
+
               mm_delete_heap(dir);
 
               return YES;
@@ -626,6 +632,8 @@ namespace Detail {
               root->fStartIN -= sizeof(HEFS_INDEX_NODE);
               root->fStartBlock -= (kHeFSSliceCount * kHeFSBlockLen);
 
+              root->fChecksum = ke_calculate_crc32((Char*) root, sizeof(HEFS_BOOT_NODE));
+
               mnt->fPacket.fPacketLba     = mnt->fLbaStart;
               mnt->fPacket.fPacketSize    = sizeof(HEFS_BOOT_NODE);
               mnt->fPacket.fPacketContent = root;
@@ -1004,11 +1012,9 @@ _Output Bool HeFileSystemParser::INodeManip(_Input DriveTrait* mnt, VoidPtr bloc
 
   if (!KStringBuilder::Equals(root->fMagic, kHeFSMagic) || root->fVersion != kHeFSVersion) {
     err_global_get() = kErrorDisk;
-    return YES;
+    return NO;
   }
 
-  if (root->fStartBlock > root->fEndBlock) return NO;
-
   SizeT cnt   = block_sz / sizeof(HEFS_INDEX_NODE);
   auto  nodes = Detail::hefsi_fetch_in(root, mnt, dir, name, kind, &cnt);
 
@@ -1021,7 +1027,7 @@ _Output Bool HeFileSystemParser::INodeManip(_Input DriveTrait* mnt, VoidPtr bloc
     SizeT cnt_slice = 0;
 
     while (cnt_slice < kHeFSSliceCount) {
-      struct HEFS_INODE_SLICE& slice = start.fSlices[cnt_slice];
+      HEFS_SLICE_NODE& slice = start.fSlices[cnt_slice];
 
       mnt->fPacket.fPacketLba     = slice.fBase + start.fOffsetSlices;
       mnt->fPacket.fPacketSize    = kHeFSBlockLen;
@@ -1174,6 +1180,9 @@ Boolean fs_init_hefs(Void) {
 
   Utf8Char contents_1[kHeFSBlockLen] = u8"ロケットにはジエットエンジン\r";
 
+  MUST_PASS(parser.INodeManip(&kMountPoint, contents_1, kHeFSBlockLen, u8"/boot",
+                              kHeFSFileKindRegular, u8"ジェット警察.txt", NO));
+
   MUST_PASS(parser.INodeManip(&kMountPoint, contents_1, kHeFSBlockLen, u8"/boot",
                               kHeFSFileKindRegular, u8"ジェット警察.txt", YES));
 
diff --git a/dev/kernel/src/KernelProcessScheduler.cc b/dev/kernel/src/KernelProcessScheduler.cc
deleted file mode 100644
index d0abfce0..00000000
--- a/dev/kernel/src/KernelProcessScheduler.cc
+++ /dev/null
@@ -1,18 +0,0 @@
-/* -------------------------------------------
-
-  Copyright (C) 2025, Amlal El Mahrouss, all rights reserved.
-
-  FILE: KernelProcessScheduler.cc
-  PURPOSE: Privileged/Ring-0 process scheduler.
-
-------------------------------------------- */
-
-#include <KernelKit/ProcessScheduler.h>
-
-/***********************************************************************************/
-/// @file KernelProcessScheduler.cc
-/// @brief Privileged/Ring-0 process scheduler.
-/// @author Amlal El Mahrouss (amlal@nekernel.org)
-/***********************************************************************************/
-
-namespace Kernel {}  // namespace Kernel
\ No newline at end of file
diff --git a/dev/kernel/src/KernelTaskScheduler.cc b/dev/kernel/src/KernelTaskScheduler.cc
new file mode 100644
index 00000000..1997c175
--- /dev/null
+++ b/dev/kernel/src/KernelTaskScheduler.cc
@@ -0,0 +1,18 @@
+/* -------------------------------------------
+
+  Copyright (C) 2025, Amlal El Mahrouss, all rights reserved.
+
+  FILE: KernelTaskScheduler.cc
+  PURPOSE: Kernel Task scheduler.
+
+------------------------------------------- */
+
+#include <KernelKit/KernelTaskScheduler.h>
+
+/***********************************************************************************/
+/// @file KernelTaskScheduler.cc
+/// @brief Kernel Task scheduler.
+/// @author Amlal El Mahrouss (amlal@nekernel.org)
+/***********************************************************************************/
+
+namespace Kernel {}  // namespace Kernel
\ No newline at end of file
diff --git a/docs/tex/hefs.tex b/docs/tex/hefs.tex
index c8b5a79b..6daf5d87 100644
--- a/docs/tex/hefs.tex
+++ b/docs/tex/hefs.tex
@@ -4,7 +4,7 @@
 \usepackage{longtable}
 \usepackage{listings}
 \geometry{margin=1in}
-\title{HeFS Filesystem Specification (v0x0103)}
+\title{HeFS Filesystem Specification (v1.3)}
 \author{Amlal El Mahrouss}
 \date{2025}
 
diff --git a/public/tools/mgmt.hefs/.keep b/public/tools/mgmt.hefs/.keep
new file mode 100644
index 00000000..e69de29b
diff --git a/public/tools/mgmt.hefs/mgmt.hefs.json b/public/tools/mgmt.hefs/mgmt.hefs.json
new file mode 100644
index 00000000..dc1181c3
--- /dev/null
+++ b/public/tools/mgmt.hefs/mgmt.hefs.json
@@ -0,0 +1,19 @@
+{
+    "compiler_path": "clang++",
+    "compiler_std": "c++20",
+    "headers_path": [
+        "./",
+        "../../../dev/kernel",
+        "../../../public/frameworks/",
+        "../../../dev/",
+        "./"
+    ],
+    "sources_path": [],
+    "output_name": "./dist/mgmt.hefs",
+    "cpp_macros": [
+        "kSampleFWVersion=0x0100",
+        "kSampleFWVersionHighest=0x0100",
+        "kSampleFWVersionLowest=0x0100",
+        "__NE_SDK__"
+    ]
+}
\ No newline at end of file
diff --git a/public/tools/mgmt.hefs/src/.keep b/public/tools/mgmt.hefs/src/.keep
new file mode 100644
index 00000000..e69de29b
diff --git a/public/tools/mgmt.hefs/vendor/.keep b/public/tools/mgmt.hefs/vendor/.keep
new file mode 100644
index 00000000..e69de29b
diff --git a/public/tools/mgmt/.keep b/public/tools/mgmt/.keep
new file mode 100644
index 00000000..e69de29b
diff --git a/public/tools/mgmt/mgmt.json b/public/tools/mgmt/mgmt.json
new file mode 100644
index 00000000..5cdd0ec7
--- /dev/null
+++ b/public/tools/mgmt/mgmt.json
@@ -0,0 +1,19 @@
+{
+    "compiler_path": "clang++",
+    "compiler_std": "c++20",
+    "headers_path": [
+        "./",
+        "../../../dev/kernel",
+        "../../../public/frameworks/",
+        "../../../dev/",
+        "./"
+    ],
+    "sources_path": [],
+    "output_name": "./dist/mgmt",
+    "cpp_macros": [
+        "kSampleFWVersion=0x0100",
+        "kSampleFWVersionHighest=0x0100",
+        "kSampleFWVersionLowest=0x0100",
+        "__NE_SDK__"
+    ]
+}
\ No newline at end of file
diff --git a/public/tools/mgmt/src/.keep b/public/tools/mgmt/src/.keep
new file mode 100644
index 00000000..e69de29b
diff --git a/public/tools/mgmt/src/CommandLine.cc b/public/tools/mgmt/src/CommandLine.cc
new file mode 100644
index 00000000..d269c894
--- /dev/null
+++ b/public/tools/mgmt/src/CommandLine.cc
@@ -0,0 +1,3 @@
+int main() {
+  return 0;
+}
\ No newline at end of file
diff --git a/public/tools/mgmt/vendor/.keep b/public/tools/mgmt/vendor/.keep
new file mode 100644
index 00000000..e69de29b
diff --git a/tooling/mk_fwrk.py b/tooling/mk_fwrk.py
index e0302754..36cc4e8e 100755
--- a/tooling/mk_fwrk.py
+++ b/tooling/mk_fwrk.py
@@ -13,7 +13,8 @@ def create_directory_structure(base_path, project_name):
                 ".keep": None
             },
             "src": {
-                ".keep": None
+                ".keep": None,
+                "CommandLine.cc": None,
             },
             "vendor": {
                 ".keep": None
@@ -40,7 +41,8 @@ def create_directory_structure(base_path, project_name):
     create_structure(base_path, structure)
 
     # Create the JSON file
-    diutil_json_path = os.path.join(base_path, project_name, f"{project_name}.json")
+    proj_json_path = os.path.join(base_path, project_name, f"{project_name}.json")
+
     manifest = {
         "compiler_path": "clang++",
         "compiler_std": "c++20",
@@ -57,9 +59,16 @@ def create_directory_structure(base_path, project_name):
         ]
     }
     
-    with open(diutil_json_path, 'w') as json_file:
+    with open(proj_json_path, 'w') as json_file:
         json.dump(manifest, json_file, indent=4)
 
+    proj_cpp_path = os.path.join(base_path, project_name, f"src/CommandLine.cc")
+
+    cpp_file = "int main() {\n\treturn 0;\n}"
+
+    with open(proj_cpp_path, 'w') as cpp_file_io:
+        cpp_file_io.write(cpp_file)
+
 if __name__ == "__main__":
     if len(sys.argv) != 2:
         print("Usage: mk_fwrk.py <project_name>")
-- 
cgit v1.2.3


From b816e857b2d3b602473bf28703ad2cff722535e5 Mon Sep 17 00:00:00 2001
From: Amlal <amlal@nekernel.org>
Date: Sat, 10 May 2025 09:45:32 +0200
Subject: dev(kernel): feat: AHCI driver improvements against 'disk hangs', and
 HeFS has been improved with better traversal, and inode/ind allocation.

Signed-off-by: Amlal <amlal@nekernel.org>
---
 dev/boot/src/HEL/AMD64/BootEFI.cc               |  9 +--
 dev/kernel/FSKit/HeFS.h                         |  5 +-
 dev/kernel/HALKit/AMD64/Storage/AHCI+Generic.cc | 23 +++---
 dev/kernel/src/FS/HeFS+FileSystemParser.cc      | 97 ++++++++++---------------
 4 files changed, 57 insertions(+), 77 deletions(-)

(limited to 'dev/kernel/FSKit')

diff --git a/dev/boot/src/HEL/AMD64/BootEFI.cc b/dev/boot/src/HEL/AMD64/BootEFI.cc
index 260d7c00..dbc12265 100644
--- a/dev/boot/src/HEL/AMD64/BootEFI.cc
+++ b/dev/boot/src/HEL/AMD64/BootEFI.cc
@@ -17,11 +17,6 @@
 #include <modules/CoreGfx/CoreGfx.h>
 #include <modules/CoreGfx/TextGfx.h>
 
-// Makes the compiler shut up.
-#ifndef kMachineModel
-#define kMachineModel "OS"
-#endif  // !kMachineModel
-
 /** Graphics related. */
 
 STATIC EfiGraphicsOutputProtocol* kGop       = nullptr;
@@ -136,14 +131,14 @@ EFI_EXTERN_C EFI_API Int32 BootloaderMain(EfiHandlePtr image_handle, EfiSystemTa
   Int32 trials = 5 * 10000000;
 
   writer.Write("BootZ: Welcome to BootZ.\r");
-  writer.Write("BootZ: Allocating sufficent memory, trying 4GB...\r");
+  writer.Write("BootZ: Allocating sufficient memory, trying 4GB...\r");
 
   while (BS->AllocatePool(EfiLoaderData, handover_hdr->f_BitMapSize,
                           &handover_hdr->f_BitMapStart) != kEfiOk) {
     --trials;
 
     if (!trials) {
-      writer.Write("BootZ: Unable to allocate sufficent memory, trying again with 2GB...\r");
+      writer.Write("BootZ: Unable to allocate sufficient memory, trying again with 2GB...\r");
 
       trials = 3 * 10000000;
 
diff --git a/dev/kernel/FSKit/HeFS.h b/dev/kernel/FSKit/HeFS.h
index f6f2d1dd..309a4338 100644
--- a/dev/kernel/FSKit/HeFS.h
+++ b/dev/kernel/FSKit/HeFS.h
@@ -29,7 +29,8 @@
 
 #define kHeFSDefaultVolumeName u8"HeFS Volume"
 
-#define kHeFSINDStartOffset (sizeof(HEFS_INDEX_NODE_DIRECTORY) + sizeof(HEFS_BOOT_NODE))
+#define kHeFSINDStartOffset (sizeof(HEFS_BOOT_NODE))
+#define kHeFSINStartOffset (sizeof(HEFS_INDEX_NODE_DIRECTORY))
 
 #define kHeFSSearchAllStr u8"*"
 
@@ -176,7 +177,7 @@ struct PACKED HEFS_INDEX_NODE final {
   /// @details Using an offset to ask fBase, and fLength to compute each slice's length.
   UInt64 fOffsetSlices;
 
-  HEFS_SLICE_NODE fSlices[kHeFSSliceCount];  /// @brief block slice
+  HEFS_SLICE_NODE fSlices[kHeFSSliceCount];  /// @brief block slice, unused as of current HeFS.
 
   Char fPad[309];
 };
diff --git a/dev/kernel/HALKit/AMD64/Storage/AHCI+Generic.cc b/dev/kernel/HALKit/AMD64/Storage/AHCI+Generic.cc
index ad4f9eeb..80053ea8 100644
--- a/dev/kernel/HALKit/AMD64/Storage/AHCI+Generic.cc
+++ b/dev/kernel/HALKit/AMD64/Storage/AHCI+Generic.cc
@@ -144,12 +144,6 @@ STATIC Void drv_std_input_output_ahci(UInt64 lba, UInt8* buffer, SizeT sector_sz
 
   lba /= sector_sz;
 
-  if (lba > kSATASectorCount) {
-    kout << "Out of range LBA.\r";
-    err_global_get() = kErrorDisk;
-    return;
-  }
-
   if (!buffer || size_buffer == 0) {
     kout << "Invalid buffer for AHCI I/O.\r";
     err_global_get() = kErrorDisk;
@@ -160,12 +154,12 @@ STATIC Void drv_std_input_output_ahci(UInt64 lba, UInt8* buffer, SizeT sector_sz
 
   UInt16 timeout = 0;
 
-  constexpr static UInt16 kTimeout = 0x7000;
+  constexpr static UInt16 kTimeout = 0x8000;
 
   while (slot == ~0UL) {
-    kout << "No free command slot found, AHCI disk is busy!\r";
-
     if (timeout > kTimeout) {
+      kout << "No free command slot found, AHCI disk is busy!\r";
+
       err_global_get() = kErrorDisk;
       return;
     }
@@ -265,7 +259,18 @@ STATIC Void drv_std_input_output_ahci(UInt64 lba, UInt8* buffer, SizeT sector_sz
   // Issue command
   kSATAHba->Ports[kSATAIndex].Ci = (1 << slot);
 
+  timeout = 0UL;
+
   while (YES) {
+    if (timeout > kTimeout) {
+      kout << "Disk hangup!\r";
+
+      err_global_get() = kErrorDisk;
+      return;
+    }
+
+    ++timeout;
+
     if (!(kSATAHba->Ports[kSATAIndex].Ci & (1 << slot))) break;
   }
 
diff --git a/dev/kernel/src/FS/HeFS+FileSystemParser.cc b/dev/kernel/src/FS/HeFS+FileSystemParser.cc
index da55432a..010dbc5d 100644
--- a/dev/kernel/src/FS/HeFS+FileSystemParser.cc
+++ b/dev/kernel/src/FS/HeFS+FileSystemParser.cc
@@ -32,7 +32,7 @@ namespace Detail {
   /***********************************************************************************/
   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);
+                          Lba& start);
 
   /***********************************************************************************/
   /// @brief Get the index node of a file or directory.
@@ -107,9 +107,8 @@ namespace Detail {
   /// @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) Void
-      hefsi_traverse_tree(HEFS_INDEX_NODE_DIRECTORY* dir, DriveTrait* mnt, const Lba& ind_start,
-                          Lba& start, const BOOL try_new) {
+  STATIC ATTRIBUTE(unused) Void hefsi_traverse_tree(HEFS_INDEX_NODE_DIRECTORY* dir, DriveTrait* mnt,
+                                                    const Lba& ind_start, Lba& start) {
     if (!mnt || !dir) return;
 
     BOOL check_is_good = NO;
@@ -149,8 +148,6 @@ namespace Detail {
           check_is_good = YES;
           continue;
         } else {
-          if (!try_new) break;
-
           if (start == 0) {
             start = ind_start;
             continue;
@@ -162,10 +159,8 @@ namespace Detail {
       }
     }
 
-    if (try_new) start += sizeof(HEFS_INDEX_NODE_DIRECTORY);
+    start += sizeof(HEFS_INDEX_NODE_DIRECTORY);
     if (start == 0) start = ind_start;
-
-    (Void)(kout << "LBA_" << hex_number(start) << kendl);
   }
 
   /***********************************************************************************/
@@ -351,7 +346,7 @@ namespace Detail {
                 break;
               }
 
-              hefsi_traverse_tree(tmpend, mnt, root->fStartIND, child_first, YES);
+              hefsi_traverse_tree(tmpend, mnt, root->fStartIND, child_first);
             }
           }
 
@@ -435,8 +430,8 @@ namespace Detail {
 
         prev_location = start;
 
-        hefsi_traverse_tree(tmpdir, mnt, root->fStartIND, start, YES);
-        if (start > root->fEndIND) break;
+        hefsi_traverse_tree(tmpdir, mnt, root->fStartIND, start);
+        if (start > root->fEndIND || start == 0) break;
       }
 
       err_global_get() = kErrorDisk;
@@ -504,6 +499,7 @@ namespace Detail {
                   err_global_get() = kErrorSuccess;
 
                   delete dir;
+                  dir = nullptr;
 
                   return node_arr;
                 }
@@ -512,8 +508,8 @@ namespace Detail {
           }
         }
 
-        hefsi_traverse_tree(dir, mnt, root->fStartIND, start, YES);
-        if (start > root->fEndIND) break;
+        hefsi_traverse_tree(dir, mnt, root->fStartIND, start);
+        if (start > root->fEndIND || start == 0) break;
       }
 
       err_global_get() = kErrorSuccess;
@@ -586,9 +582,8 @@ namespace Detail {
               SizeT cnt = 0ULL;
 
               while (cnt < kHeFSSliceCount) {
-                HEFS_SLICE_NODE& slice = node->fSlices[cnt];
-                slice.fBase            = offset;
-                slice.fLength          = kHeFSBlockLen;
+                node->fSlices[cnt].fBase   = offset;
+                node->fSlices[cnt].fLength = kHeFSBlockLen;
                 offset += kHeFSBlockLen;
 
                 ++cnt;
@@ -601,7 +596,7 @@ namespace Detail {
               mnt->fOutput(mnt->fPacket);
 
               root->fStartIN += sizeof(HEFS_INDEX_NODE);
-              root->fStartBlock += (kHeFSSliceCount * kHeFSBlockLen);
+              root->fStartBlock += kHeFSBlockLen;
 
               root->fChecksum = ke_calculate_crc32((Char*) root, sizeof(HEFS_BOOT_NODE));
 
@@ -665,7 +660,7 @@ namespace Detail {
           }
         }
 
-        hefsi_traverse_tree(dir, mnt, root->fStartIND, start, YES);
+        hefsi_traverse_tree(dir, mnt, root->fStartIND, start);
         if (start > root->fEndIND || start == 0) break;
       }
 
@@ -737,7 +732,7 @@ namespace Detail {
           mnt->fOutput(mnt->fPacket);
         }
 
-        hefsi_traverse_tree(dir, mnt, root->fStartIND, start, NO);
+        hefsi_traverse_tree(dir, mnt, root->fStartIND, start);
       }
 
       err_global_get() = kErrorSuccess;
@@ -827,23 +822,26 @@ _Output Bool HeFileSystemParser::Format(_Input _Output DriveTrait* mnt, _Input c
 
   MUST_PASS(root->fSectorSize);
 
-  const SizeT max_lba = mnt->fLbaEnd / root->fSectorSize;
+  /// @note all HeFS strucutres are equal to 512, so here it's fine, unless fSectoSize is 2048.
+  const SizeT max_lba = (mnt->fLbaEnd / 4) / root->fSectorSize;
 
-  const SizeT dir_max   = max_lba / 20;  // 20% for directory metadata
-  const SizeT inode_max = max_lba / 20;  // 10% for inodes
+  const SizeT dir_max   = max_lba / 30;   // 20% for directory inodes
+  const SizeT inode_max = max_lba / 60;  // 30% for inodes
 
   root->fStartIND = mnt->fLbaStart + kHeFSINDStartOffset;
   root->fEndIND   = root->fStartIND + dir_max;
 
-  root->fStartIN = root->fEndIND + sizeof(HEFS_INDEX_NODE_DIRECTORY);
+  root->fStartIN = root->fEndIND;
   root->fEndIN   = root->fStartIN + inode_max;
 
-  constexpr SizeT kHeFSPreallocateCount = 0x6UL;
+  root->fStartBlock = root->fEndIN;
+  root->fEndBlock   = mnt->fLbaEnd;
+
+  constexpr const SizeT kHeFSPreallocateCount = 0x6UL;
 
   root->fINDCount = 0;
 
-  // let's lie here.
-  root->fDiskSize   = mnt->fLbaEnd;
+  root->fDiskSize   = drv_std_get_size();
   root->fDiskStatus = kHeFSStatusUnlocked;
 
   root->fDiskFlags = flags;
@@ -856,9 +854,6 @@ _Output Bool HeFileSystemParser::Format(_Input _Output DriveTrait* mnt, _Input c
     root->fDiskKind = kHeFSUnknown;
   }
 
-  root->fStartBlock = root->fEndIN + sizeof(HEFS_INDEX_NODE);
-  root->fEndBlock   = mnt->fLbaEnd;
-
   root->fVersion = kHeFSVersion;
 
   root->fVID = kHeFSInvalidVID;
@@ -1015,48 +1010,32 @@ _Output Bool HeFileSystemParser::INodeManip(_Input DriveTrait* mnt, VoidPtr bloc
     return NO;
   }
 
-  SizeT cnt   = block_sz / sizeof(HEFS_INDEX_NODE);
+  SizeT cnt   = block_sz / sizeof(HEFS_INDEX_NODE) + 1;
   auto  nodes = Detail::hefsi_fetch_in(root, mnt, dir, name, kind, &cnt);
 
   if (!nodes) return NO;
 
-  SizeT sz_out = 0;
-
   for (SizeT i = 0UL; i < cnt; ++i) {
     auto& start     = nodes[i];
     SizeT cnt_slice = 0;
 
-    while (cnt_slice < kHeFSSliceCount) {
-      HEFS_SLICE_NODE& slice = start.fSlices[cnt_slice];
-
-      mnt->fPacket.fPacketLba     = slice.fBase + start.fOffsetSlices;
-      mnt->fPacket.fPacketSize    = kHeFSBlockLen;
-      mnt->fPacket.fPacketContent = block;
-
-      if (mnt->fPacket.fPacketLba > root->fEndBlock) {
-        goto inode_manip_fail;
-      }
-
-      if (!in) {
-        mnt->fOutput(mnt->fPacket);
-        delete[] nodes;
-        return YES;
-      } else {
-        mnt->fInput(mnt->fPacket);
-        sz_out += kHeFSBlockLen;
+    mnt->fPacket.fPacketLba     = start.fOffsetSlices;
+    mnt->fPacket.fPacketSize    = kHeFSBlockLen;
+    mnt->fPacket.fPacketContent = block;
 
-        if (sz_out >= block_sz) {
-          delete[] nodes;
-          return YES;
-        }
-      }
-
-      ++cnt_slice;
+    if (in) {
+      mnt->fInput(mnt->fPacket);
+    } else {
+      mnt->fOutput(mnt->fPacket);
     }
+
+    delete[] nodes;
+    return mnt->fPacket.fPacketGood == YES;
   }
 
-inode_manip_fail:
   delete[] nodes;
+  nodes = nullptr;
+
   return NO;
 }
 
-- 
cgit v1.2.3


From a3dde6ad12d8b607d493ddac4f54c8f5d2c3082c Mon Sep 17 00:00:00 2001
From: Amlal <amlal@nekernel.org>
Date: Sat, 10 May 2025 14:04:31 +0200
Subject: dev(kernel): saving changes regarding HeFS, and also for the 0.0.2e2
 release.

Signed-off-by: Amlal <amlal@nekernel.org>
---
 dev/boot/BootKit/HW/SATA.h                 |  4 ++--
 dev/kernel/FSKit/HeFS.h                    |  3 ++-
 dev/kernel/src/FS/HeFS+FileSystemParser.cc | 35 ++++++++++++++++++++++--------
 docs/tex/hefs.tex                          |  2 +-
 4 files changed, 31 insertions(+), 13 deletions(-)

(limited to 'dev/kernel/FSKit')

diff --git a/dev/boot/BootKit/HW/SATA.h b/dev/boot/BootKit/HW/SATA.h
index 8cf48ec7..7285ceac 100644
--- a/dev/boot/BootKit/HW/SATA.h
+++ b/dev/boot/BootKit/HW/SATA.h
@@ -10,6 +10,8 @@
 #include <CompilerKit/CompilerKit.h>
 #include <modules/AHCI/AHCI.h>
 
+#define kAHCISectorSz (4096)
+
 class BootDeviceSATA final {
  public:
   explicit BootDeviceSATA() noexcept;
@@ -40,5 +42,3 @@ class BootDeviceSATA final {
  private:
   SATATrait mTrait;
 };
-
-#define kAHCISectorSz 4096
diff --git a/dev/kernel/FSKit/HeFS.h b/dev/kernel/FSKit/HeFS.h
index 309a4338..dda9f041 100644
--- a/dev/kernel/FSKit/HeFS.h
+++ b/dev/kernel/FSKit/HeFS.h
@@ -175,7 +175,8 @@ struct PACKED HEFS_INDEX_NODE final {
 
   /// @brief Extents system by using blocks
   /// @details Using an offset to ask fBase, and fLength to compute each slice's length.
-  UInt64 fOffsetSlices;
+  UInt32 fOffsetSliceLow;
+  UInt32 fOffsetSliceHigh;
 
   HEFS_SLICE_NODE fSlices[kHeFSSliceCount];  /// @brief block slice, unused as of current HeFS.
 
diff --git a/dev/kernel/src/FS/HeFS+FileSystemParser.cc b/dev/kernel/src/FS/HeFS+FileSystemParser.cc
index 010dbc5d..a62e3b58 100644
--- a/dev/kernel/src/FS/HeFS+FileSystemParser.cc
+++ b/dev/kernel/src/FS/HeFS+FileSystemParser.cc
@@ -575,7 +575,13 @@ namespace Detail {
 
               node->fChecksum = ke_calculate_crc32((Char*) node, sizeof(HEFS_INDEX_NODE));
 
-              node->fOffsetSlices = root->fStartBlock;
+              if (root->fStartBlock > (1ULL << 21)) {
+                node->fOffsetSliceLow  = (UInt32) (root->fStartBlock & 0xFFFFFFFF);
+                node->fOffsetSliceHigh = (UInt32) (root->fStartBlock >> 32);
+              } else {
+                node->fOffsetSliceLow  = root->fStartBlock;
+                node->fOffsetSliceHigh = 0UL;
+              }
 
               auto offset = kHeFSBlockLen;
 
@@ -624,8 +630,11 @@ namespace Detail {
                 continue;
               }
 
+              node->fOffsetSliceLow  = 0;
+              node->fOffsetSliceHigh = 0;
+
               root->fStartIN -= sizeof(HEFS_INDEX_NODE);
-              root->fStartBlock -= (kHeFSSliceCount * kHeFSBlockLen);
+              root->fStartBlock -= kHeFSBlockLen;
 
               root->fChecksum = ke_calculate_crc32((Char*) root, sizeof(HEFS_BOOT_NODE));
 
@@ -823,9 +832,9 @@ _Output Bool HeFileSystemParser::Format(_Input _Output DriveTrait* mnt, _Input c
   MUST_PASS(root->fSectorSize);
 
   /// @note all HeFS strucutres are equal to 512, so here it's fine, unless fSectoSize is 2048.
-  const SizeT max_lba = (mnt->fLbaEnd / 4) / root->fSectorSize;
+  const SizeT max_lba = (mnt->fLbaEnd) / root->fSectorSize;
 
-  const SizeT dir_max   = max_lba / 30;   // 20% for directory inodes
+  const SizeT dir_max   = max_lba / 30;  // 20% for directory inodes
   const SizeT inode_max = max_lba / 60;  // 30% for inodes
 
   root->fStartIND = mnt->fLbaStart + kHeFSINDStartOffset;
@@ -835,7 +844,7 @@ _Output Bool HeFileSystemParser::Format(_Input _Output DriveTrait* mnt, _Input c
   root->fEndIN   = root->fStartIN + inode_max;
 
   root->fStartBlock = root->fEndIN;
-  root->fEndBlock   = mnt->fLbaEnd;
+  root->fEndBlock   = drv_std_get_size();
 
   constexpr const SizeT kHeFSPreallocateCount = 0x6UL;
 
@@ -872,6 +881,8 @@ _Output Bool HeFileSystemParser::Format(_Input _Output DriveTrait* mnt, _Input c
   (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);
@@ -989,7 +1000,7 @@ _Output Bool HeFileSystemParser::INodeManip(_Input DriveTrait* mnt, VoidPtr bloc
     return NO;
   }
 
-  HEFS_BOOT_NODE* root = (HEFS_BOOT_NODE*) RTL_ALLOCA(sizeof(HEFS_BOOT_NODE));
+  HEFS_BOOT_NODE* root = (HEFS_BOOT_NODE*) mm_new_heap(sizeof(HEFS_BOOT_NODE), Yes, No);
 
   if (!root) {
     err_global_get() = kErrorInvalidData;
@@ -1016,10 +1027,14 @@ _Output Bool HeFileSystemParser::INodeManip(_Input DriveTrait* mnt, VoidPtr bloc
   if (!nodes) return NO;
 
   for (SizeT i = 0UL; i < cnt; ++i) {
-    auto& start     = nodes[i];
-    SizeT cnt_slice = 0;
+    auto& start = nodes[i];
 
-    mnt->fPacket.fPacketLba     = start.fOffsetSlices;
+    kout << hex_number(start.fHashPath) << kendl;
+    kout << hex_number(start.fOffsetSliceLow) << kendl;
+
+    if (!start.fHashPath || !start.fOffsetSliceLow) continue;
+
+    mnt->fPacket.fPacketLba     = start.fOffsetSliceLow + start.fOffsetSliceHigh;
     mnt->fPacket.fPacketSize    = kHeFSBlockLen;
     mnt->fPacket.fPacketContent = block;
 
@@ -1029,6 +1044,7 @@ _Output Bool HeFileSystemParser::INodeManip(_Input DriveTrait* mnt, VoidPtr bloc
       mnt->fOutput(mnt->fPacket);
     }
 
+    mm_delete_heap((VoidPtr) root);
     delete[] nodes;
     return mnt->fPacket.fPacketGood == YES;
   }
@@ -1036,6 +1052,7 @@ _Output Bool HeFileSystemParser::INodeManip(_Input DriveTrait* mnt, VoidPtr bloc
   delete[] nodes;
   nodes = nullptr;
 
+  mm_delete_heap((VoidPtr) root);
   return NO;
 }
 
diff --git a/docs/tex/hefs.tex b/docs/tex/hefs.tex
index 29370fbc..e5a08049 100644
--- a/docs/tex/hefs.tex
+++ b/docs/tex/hefs.tex
@@ -111,7 +111,7 @@ Contains file metadata and block layout.
   \item \texttt{fSymLink} - if set, \texttt{fHashPath} represents the symlink target
   \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
+  \item Block data: \texttt{fOffsetSliceLow}, \texttt{fSlices[kHeFSSliceCount]} as (base, length) pairs
 \end{itemize}
 
 \subsection{HEFS\_INDEX\_NODE\_DIRECTORY}\label{subsec:hefs_index_node_directory}
-- 
cgit v1.2.3


From 9a33591a431698fc7f50e1cdc97fd3c22955365c Mon Sep 17 00:00:00 2001
From: Amlal <amlal@nekernel.org>
Date: Sat, 10 May 2025 18:38:13 +0200
Subject: dev(kernel/HeFS): code cleanup, and improvements on the FS driver
 code.

Signed-off-by: Amlal <amlal@nekernel.org>
---
 dev/boot/amd64-desktop.make                |  2 +-
 dev/kernel/FSKit/HeFS.h                    |  1 +
 dev/kernel/src/FS/HeFS+FileSystemParser.cc | 52 +++++++++++++-----------------
 3 files changed, 25 insertions(+), 30 deletions(-)

(limited to 'dev/kernel/FSKit')

diff --git a/dev/boot/amd64-desktop.make b/dev/boot/amd64-desktop.make
index 652ba31e..c660df87 100644
--- a/dev/boot/amd64-desktop.make
+++ b/dev/boot/amd64-desktop.make
@@ -131,7 +131,7 @@ run-efi-amd64-ata: run-efi-amd64-ata-dma
 # img_2 is the rescue disk. img is the bootable disk, as provided by the NeKernel specs.
 .PHONY: epm-img
 epm-img:
-	qemu-img create -f raw $(IMG) 4G
+	qemu-img create -f raw $(IMG) 8G
 
 .PHONY: efi
 efi:
diff --git a/dev/kernel/FSKit/HeFS.h b/dev/kernel/FSKit/HeFS.h
index dda9f041..c4f31836 100644
--- a/dev/kernel/FSKit/HeFS.h
+++ b/dev/kernel/FSKit/HeFS.h
@@ -178,6 +178,7 @@ struct PACKED HEFS_INDEX_NODE final {
   UInt32 fOffsetSliceLow;
   UInt32 fOffsetSliceHigh;
 
+  ATTRIBUTE(deprecated)
   HEFS_SLICE_NODE fSlices[kHeFSSliceCount];  /// @brief block slice, unused as of current HeFS.
 
   Char fPad[309];
diff --git a/dev/kernel/src/FS/HeFS+FileSystemParser.cc b/dev/kernel/src/FS/HeFS+FileSystemParser.cc
index a62e3b58..b2d39dbe 100644
--- a/dev/kernel/src/FS/HeFS+FileSystemParser.cc
+++ b/dev/kernel/src/FS/HeFS+FileSystemParser.cc
@@ -457,14 +457,14 @@ namespace Detail {
                                                                    const Utf8Char* file_name,
                                                                    UInt8 kind, SizeT* cnt) {
     if (mnt && cnt) {
-      auto start = root->fStartIND;
-
-      if (start > root->fEndIND) return nullptr;
+      if (root->fStartIND > root->fEndIND) return nullptr;
       if (root->fStartIN > root->fEndIN) return nullptr;
 
+      auto start = root->fStartIND;
+
       auto start_cnt = 0UL;
 
-      HEFS_INDEX_NODE* node_arr = new HEFS_INDEX_NODE[*cnt + 1];
+      HEFS_INDEX_NODE* node_arr = new HEFS_INDEX_NODE[*cnt];
 
       if (!node_arr) {
         return nullptr;
@@ -481,23 +481,27 @@ namespace Detail {
         mnt->fInput(mnt->fPacket);
 
         if (hefsi_hash_64(dir_name) == dir->fHashPath && dir->fKind == kHeFSFileKindDirectory) {
+          HEFS_INDEX_NODE* node = new HEFS_INDEX_NODE();
+
           for (SizeT inode_index = 0UL; inode_index < kHeFSSliceCount; ++inode_index) {
             if (dir->fINSlices[inode_index] != 0) {
-              HEFS_INDEX_NODE* node = (HEFS_INDEX_NODE*) RTL_ALLOCA(sizeof(HEFS_INDEX_NODE));
-
               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 (hefsi_hash_64(file_name) == node->fHashPath && node->fKind == kind &&
+                  ke_calculate_crc32((Char*) node, sizeof(HEFS_INDEX_NODE)) == node->fChecksum) {
                 node_arr[start_cnt] = *node;
                 ++start_cnt;
 
                 if (start_cnt > *cnt) {
                   err_global_get() = kErrorSuccess;
 
+                  delete node;
+                  node = nullptr;
+
                   delete dir;
                   dir = nullptr;
 
@@ -506,6 +510,9 @@ namespace Detail {
               }
             }
           }
+
+          delete node;
+          node = nullptr;
         }
 
         hefsi_traverse_tree(dir, mnt, root->fStartIND, start);
@@ -573,27 +580,15 @@ namespace Detail {
 
               auto lba = dir->fINSlices[inode_index];
 
-              node->fChecksum = ke_calculate_crc32((Char*) node, sizeof(HEFS_INDEX_NODE));
-
               if (root->fStartBlock > (1ULL << 21)) {
                 node->fOffsetSliceLow  = (UInt32) (root->fStartBlock & 0xFFFFFFFF);
                 node->fOffsetSliceHigh = (UInt32) (root->fStartBlock >> 32);
               } else {
-                node->fOffsetSliceLow  = root->fStartBlock;
+                node->fOffsetSliceLow  = (UInt32) root->fStartBlock;
                 node->fOffsetSliceHigh = 0UL;
               }
 
-              auto offset = kHeFSBlockLen;
-
-              SizeT cnt = 0ULL;
-
-              while (cnt < kHeFSSliceCount) {
-                node->fSlices[cnt].fBase   = offset;
-                node->fSlices[cnt].fLength = kHeFSBlockLen;
-                offset += kHeFSBlockLen;
-
-                ++cnt;
-              }
+              node->fChecksum = ke_calculate_crc32((Char*) node, sizeof(HEFS_INDEX_NODE));
 
               mnt->fPacket.fPacketLba     = lba;
               mnt->fPacket.fPacketSize    = sizeof(HEFS_INDEX_NODE);
@@ -832,10 +827,10 @@ _Output Bool HeFileSystemParser::Format(_Input _Output DriveTrait* mnt, _Input c
   MUST_PASS(root->fSectorSize);
 
   /// @note all HeFS strucutres are equal to 512, so here it's fine, unless fSectoSize is 2048.
-  const SizeT max_lba = (mnt->fLbaEnd) / root->fSectorSize;
+  const SizeT max_lba = drv_std_get_size() / root->fSectorSize;
 
-  const SizeT dir_max   = max_lba / 30;  // 20% for directory inodes
-  const SizeT inode_max = max_lba / 60;  // 30% for inodes
+  const SizeT dir_max   = max_lba / 5;  // 20% for directory inodes
+  const SizeT inode_max = max_lba / 3;  // 30% for inodes
 
   root->fStartIND = mnt->fLbaStart + kHeFSINDStartOffset;
   root->fEndIND   = root->fStartIND + dir_max;
@@ -846,8 +841,6 @@ _Output Bool HeFileSystemParser::Format(_Input _Output DriveTrait* mnt, _Input c
   root->fStartBlock = root->fEndIN;
   root->fEndBlock   = drv_std_get_size();
 
-  constexpr const SizeT kHeFSPreallocateCount = 0x6UL;
-
   root->fINDCount = 0;
 
   root->fDiskSize   = drv_std_get_size();
@@ -889,10 +882,11 @@ _Output Bool HeFileSystemParser::Format(_Input _Output DriveTrait* mnt, _Input c
 
   if (!mnt->fPacket.fPacketGood) {
     err_global_get() = kErrorDiskIsCorrupted;
-
     return NO;
   }
 
+  constexpr const SizeT kHeFSPreallocateCount = 0x6UL;
+
   const Utf8Char* kFileMap[kHeFSPreallocateCount] = {u8"/",        u8"/boot",    u8"/system",
                                                      u8"/network", u8"/devices", u8"/media"};
 
@@ -1135,7 +1129,7 @@ _Output Bool HeFileSystemParser::INodeCtlManip(_Input DriveTrait* mnt, _Input co
   node->fSize     = 0;
   node->fKind     = kind;
   node->fFlags    = flags;
-  node->fChecksum = ke_calculate_crc32((Char*) node, sizeof(HEFS_INDEX_NODE));
+  node->fChecksum = 0;
   node->fGID      = 0;
   node->fUID      = 0;
   node->fHashPath = Detail::hefsi_hash_64(name);
@@ -1174,7 +1168,7 @@ Boolean fs_init_hefs(Void) {
   MUST_PASS(parser.CreateINode(&kMountPoint, kHeFSEncodingFlagsBinary | kHeFSFlagsReadOnly,
                                u8"/boot", u8"ジェット警察.txt", kHeFSFileKindRegular));
 
-  Utf8Char contents_1[kHeFSBlockLen] = u8"ロケットにはジエットエンジン\r";
+  Utf8Char contents_1[kHeFSBlockLen] = {u8"ロケットにはジエットエンジン\r\0"};
 
   MUST_PASS(parser.INodeManip(&kMountPoint, contents_1, kHeFSBlockLen, u8"/boot",
                               kHeFSFileKindRegular, u8"ジェット警察.txt", NO));
-- 
cgit v1.2.3


From 81bcbc74da189bfe5f3b1fd70ae83fb85a2ce859 Mon Sep 17 00:00:00 2001
From: Amlal <amlal@nekernel.org>
Date: Sun, 11 May 2025 01:27:29 +0200
Subject: dev(feat:kernel): Working Core Layer of HeFS (Write/Read)

Signed-off-by: Amlal <amlal@nekernel.org>
---
 dev/boot/BootKit/BootKit.h                      |   9 +-
 dev/boot/BootKit/HW/SATA.h                      |   4 +-
 dev/boot/src/BootString.cc                      |   2 +-
 dev/boot/src/HEL/AMD64/BootATA+Next.cc          |   8 +-
 dev/boot/src/HEL/AMD64/BootATA.cc               |   8 +-
 dev/boot/src/HEL/AMD64/BootSATA.cc              |   4 +-
 dev/boot/src/docs/KERN_VER.md                   |   2 +-
 dev/kernel/FSKit/HeFS.h                         |   7 +-
 dev/kernel/HALKit/AMD64/Storage/AHCI+Generic.cc |   3 +-
 dev/kernel/NewKit/Utils.h                       |   6 +-
 dev/kernel/src/FS/HeFS+FileSystemParser.cc      | 165 +++++++++---------------
 dev/kernel/src/MemoryMgr.cc                     |   2 +-
 dev/kernel/src/UtfUtils.cc                      |  10 ++
 13 files changed, 101 insertions(+), 129 deletions(-)

(limited to 'dev/kernel/FSKit')

diff --git a/dev/boot/BootKit/BootKit.h b/dev/boot/BootKit/BootKit.h
index 181be973..cc80e359 100644
--- a/dev/boot/BootKit/BootKit.h
+++ b/dev/boot/BootKit/BootKit.h
@@ -40,7 +40,7 @@
 /***********************************************************************************/
 
 namespace Boot {
-EXTERN void ThrowError(const WideChar* errorCode, const WideChar* reason) noexcept;
+void ThrowError(const WideChar* errorCode, const WideChar* reason) noexcept;
 
 class BootTextWriter;
 class BootFileReader;
@@ -51,7 +51,8 @@ typedef Char* PEFImagePtr;
 typedef Char* PEImagePtr;
 
 typedef WideChar CharacterTypeUTF16;
-typedef Char     CharacterTypeUTF8;
+typedef Char     CharacterTypeASCII;
+typedef char8_t  CharacterTypeUTF8;
 
 using namespace Kernel;
 
@@ -86,7 +87,7 @@ class BootTextWriter final {
 
 Kernel::SizeT BCopyMem(CharacterTypeUTF16* dest, CharacterTypeUTF16* src, const Kernel::SizeT len);
 
-Kernel::SizeT BSetMem(CharacterTypeUTF8* src, const CharacterTypeUTF8 byte,
+Kernel::SizeT BSetMem(CharacterTypeASCII* src, const CharacterTypeASCII byte,
                       const Kernel::SizeT len);
 
 /// String length functions.
@@ -151,7 +152,7 @@ typedef UInt8* BlobType;
 /// @brief Bootloader Version String.
 class BVersionString final {
  public:
-  static const CharacterTypeUTF8* The() { return BOOTLOADER_VERSION; }
+  static const CharacterTypeASCII* The() { return BOOTLOADER_VERSION; }
 };
 
 /***********************************************************************************/
diff --git a/dev/boot/BootKit/HW/SATA.h b/dev/boot/BootKit/HW/SATA.h
index 7285ceac..eecf426d 100644
--- a/dev/boot/BootKit/HW/SATA.h
+++ b/dev/boot/BootKit/HW/SATA.h
@@ -34,8 +34,8 @@ class BootDeviceSATA final {
 
   constexpr static auto kSectorSize = kAHCISectorSize;
 
-  BootDeviceSATA& Read(Boot::CharacterTypeUTF8* Buf, const Kernel::SizeT SecCount);
-  BootDeviceSATA& Write(Boot::CharacterTypeUTF8* Buf, const Kernel::SizeT SecCount);
+  BootDeviceSATA& Read(Boot::CharacterTypeASCII* Buf, const Kernel::SizeT SecCount);
+  BootDeviceSATA& Write(Boot::CharacterTypeASCII* Buf, const Kernel::SizeT SecCount);
 
   SATATrait& Leak();
 
diff --git a/dev/boot/src/BootString.cc b/dev/boot/src/BootString.cc
index 8762a151..277f3273 100644
--- a/dev/boot/src/BootString.cc
+++ b/dev/boot/src/BootString.cc
@@ -62,7 +62,7 @@ Kernel::SizeT Boot::BSetMem(CharacterTypeUTF16* src, const CharacterTypeUTF16 by
   return cnt;
 }
 
-Kernel::SizeT Boot::BSetMem(CharacterTypeUTF8* src, const CharacterTypeUTF8 byte,
+Kernel::SizeT Boot::BSetMem(CharacterTypeASCII* src, const CharacterTypeASCII byte,
                             const Kernel::SizeT len) {
   if (!src) return 0;
 
diff --git a/dev/boot/src/HEL/AMD64/BootATA+Next.cc b/dev/boot/src/HEL/AMD64/BootATA+Next.cc
index 723224c1..547d4f99 100644
--- a/dev/boot/src/HEL/AMD64/BootATA+Next.cc
+++ b/dev/boot/src/HEL/AMD64/BootATA+Next.cc
@@ -103,7 +103,7 @@ ATAInit_Retry:
   return true;
 }
 
-Void boot_ata_read(UInt64 Lba, UInt16 IO, UInt8 Master, CharacterTypeUTF8* Buf, SizeT SectorSz,
+Void boot_ata_read(UInt64 Lba, UInt16 IO, UInt8 Master, CharacterTypeASCII* Buf, SizeT SectorSz,
                    SizeT Size) {
   Lba /= SectorSz;
 
@@ -136,7 +136,7 @@ Void boot_ata_read(UInt64 Lba, UInt16 IO, UInt8 Master, CharacterTypeUTF8* Buf,
   }
 }
 
-Void boot_ata_write(UInt64 Lba, UInt16 IO, UInt8 Master, CharacterTypeUTF8* Buf, SizeT SectorSz,
+Void boot_ata_write(UInt64 Lba, UInt16 IO, UInt8 Master, CharacterTypeASCII* Buf, SizeT SectorSz,
                     SizeT Size) {
   Lba /= SectorSz;
 
@@ -208,7 +208,7 @@ BootDeviceATA::operator bool() {
   @param Sz Sector size
   @param Buf buffer
 */
-BootDeviceATA& BootDeviceATA::Read(CharacterTypeUTF8* Buf, SizeT SectorSz) {
+BootDeviceATA& BootDeviceATA::Read(CharacterTypeASCII* Buf, SizeT SectorSz) {
   if (!boot_ata_detected()) {
     Leak().mErr = true;
     return *this;
@@ -229,7 +229,7 @@ BootDeviceATA& BootDeviceATA::Read(CharacterTypeUTF8* Buf, SizeT SectorSz) {
   @param Sz Sector size
   @param Buf buffer
 */
-BootDeviceATA& BootDeviceATA::Write(CharacterTypeUTF8* Buf, SizeT SectorSz) {
+BootDeviceATA& BootDeviceATA::Write(CharacterTypeASCII* Buf, SizeT SectorSz) {
   if (!boot_ata_detected()) {
     Leak().mErr = true;
     return *this;
diff --git a/dev/boot/src/HEL/AMD64/BootATA.cc b/dev/boot/src/HEL/AMD64/BootATA.cc
index 0fd46832..e1ccbfc3 100644
--- a/dev/boot/src/HEL/AMD64/BootATA.cc
+++ b/dev/boot/src/HEL/AMD64/BootATA.cc
@@ -101,7 +101,7 @@ ATAInit_Retry:
   return NO;
 }
 
-Void boot_ata_read(UInt64 Lba, UInt16 IO, UInt8 Master, CharacterTypeUTF8* Buf, SizeT SectorSz,
+Void boot_ata_read(UInt64 Lba, UInt16 IO, UInt8 Master, CharacterTypeASCII* Buf, SizeT SectorSz,
                    SizeT Size) {
   Lba /= SectorSz;
 
@@ -130,7 +130,7 @@ Void boot_ata_read(UInt64 Lba, UInt16 IO, UInt8 Master, CharacterTypeUTF8* Buf,
   }
 }
 
-Void boot_ata_write(UInt64 Lba, UInt16 IO, UInt8 Master, CharacterTypeUTF8* Buf, SizeT SectorSz,
+Void boot_ata_write(UInt64 Lba, UInt16 IO, UInt8 Master, CharacterTypeASCII* Buf, SizeT SectorSz,
                     SizeT Size) {
   Lba /= SectorSz;
 
@@ -196,7 +196,7 @@ BootDeviceATA::operator bool() {
   @param Sz Sector size
   @param Buf buffer
 */
-BootDeviceATA& BootDeviceATA::Read(CharacterTypeUTF8* Buf, SizeT SectorSz) {
+BootDeviceATA& BootDeviceATA::Read(CharacterTypeASCII* Buf, SizeT SectorSz) {
   if (!boot_ata_detected()) {
     Leak().mErr = true;
     return *this;
@@ -217,7 +217,7 @@ BootDeviceATA& BootDeviceATA::Read(CharacterTypeUTF8* Buf, SizeT SectorSz) {
   @param Sz Sector size
   @param Buf buffer
 */
-BootDeviceATA& BootDeviceATA::Write(CharacterTypeUTF8* Buf, SizeT SectorSz) {
+BootDeviceATA& BootDeviceATA::Write(CharacterTypeASCII* Buf, SizeT SectorSz) {
   if (!boot_ata_detected()) {
     Leak().mErr = true;
     return *this;
diff --git a/dev/boot/src/HEL/AMD64/BootSATA.cc b/dev/boot/src/HEL/AMD64/BootSATA.cc
index 2b1bc78e..b0b0b52f 100644
--- a/dev/boot/src/HEL/AMD64/BootSATA.cc
+++ b/dev/boot/src/HEL/AMD64/BootSATA.cc
@@ -48,7 +48,7 @@ BootDeviceSATA::BootDeviceSATA() noexcept {
   @param Sz Sector size
   @param Buf buffer
 */
-BootDeviceSATA& BootDeviceSATA::Read(CharacterTypeUTF8* Buf, SizeT SectorSz) {
+BootDeviceSATA& BootDeviceSATA::Read(CharacterTypeASCII* Buf, SizeT SectorSz) {
   NE_UNUSED(Buf);
   NE_UNUSED(SectorSz);
 
@@ -62,7 +62,7 @@ BootDeviceSATA& BootDeviceSATA::Read(CharacterTypeUTF8* Buf, SizeT SectorSz) {
   @param Sz Sector size
   @param Buf buffer
 */
-BootDeviceSATA& BootDeviceSATA::Write(CharacterTypeUTF8* Buf, SizeT SectorSz) {
+BootDeviceSATA& BootDeviceSATA::Write(CharacterTypeASCII* Buf, SizeT SectorSz) {
   NE_UNUSED(Buf);
   NE_UNUSED(SectorSz);
 
diff --git a/dev/boot/src/docs/KERN_VER.md b/dev/boot/src/docs/KERN_VER.md
index abe3e823..cabdb1d2 100644
--- a/dev/boot/src/docs/KERN_VER.md
+++ b/dev/boot/src/docs/KERN_VER.md
@@ -1,4 +1,4 @@
-# /props/kern_ver
+# The `/props/kern_ver` NVRAM variable
 
 The `/props/kern_ver` variable is used to track NeKernel's current version in a BCD format.
 
diff --git a/dev/kernel/FSKit/HeFS.h b/dev/kernel/FSKit/HeFS.h
index c4f31836..85421069 100644
--- a/dev/kernel/FSKit/HeFS.h
+++ b/dev/kernel/FSKit/HeFS.h
@@ -198,8 +198,7 @@ struct PACKED HEFS_INDEX_NODE_DIRECTORY final {
   UInt64 fHashPath;  /// @brief Directory path as FNV hash.
 
   UInt32 fFlags;       /// @brief File flags.
-  UInt16 fKind;        /// @brief File kind. (Regular, Directory, Block, Character, FIFO, Socket,
-                       /// Symbolic Link, Unknown).
+  UInt16 fReserved;    /// @note Reserved for future use.
   UInt32 fEntryCount;  /// @brief Entry Count of this directory inode.
   UInt32 fChecksum;    /// @brief Checksum of the file, index node checksum.
 
@@ -405,8 +404,8 @@ class HeFileSystemParser final {
                            const Utf8Char* name, const UInt8 kind);
 
   _Output Bool INodeManip(_Input DriveTrait* drive, VoidPtr block, SizeT block_sz,
-                          const Utf8Char* dir, const UInt8 kind, const Utf8Char* name,
-                          const BOOL in);
+                          const Utf8Char* dir, const Utf8Char* name, const UInt8 kind,
+                          const BOOL input);
 
  private:
   _Output Bool INodeCtlManip(_Input DriveTrait* drive, _Input const Int32 flags,
diff --git a/dev/kernel/HALKit/AMD64/Storage/AHCI+Generic.cc b/dev/kernel/HALKit/AMD64/Storage/AHCI+Generic.cc
index 80053ea8..bb6caf87 100644
--- a/dev/kernel/HALKit/AMD64/Storage/AHCI+Generic.cc
+++ b/dev/kernel/HALKit/AMD64/Storage/AHCI+Generic.cc
@@ -264,8 +264,7 @@ STATIC Void drv_std_input_output_ahci(UInt64 lba, UInt8* buffer, SizeT sector_sz
   while (YES) {
     if (timeout > kTimeout) {
       kout << "Disk hangup!\r";
-
-      err_global_get() = kErrorDisk;
+      kSATAHba->Ports[kSATAIndex].Ci = 0;
       return;
     }
 
diff --git a/dev/kernel/NewKit/Utils.h b/dev/kernel/NewKit/Utils.h
index 0cf0484a..e3420d84 100644
--- a/dev/kernel/NewKit/Utils.h
+++ b/dev/kernel/NewKit/Utils.h
@@ -26,7 +26,7 @@ Int         rt_to_uppercase(Int c);
 Int         rt_to_lower(Int c);
 voidPtr     rt_string_in_string(const Char* in, const Char* needle);
 char*       rt_string_has_char(Char* str, Char chr);
-
-Int  urt_copy_memory(const voidPtr src, voidPtr dst, Size len);
-Size urt_string_len(const Utf8Char* str);
+Void        urt_set_memory(const voidPtr src, UInt32 dst, Size len);
+Int         urt_copy_memory(const voidPtr src, voidPtr dst, Size len);
+Size        urt_string_len(const Utf8Char* str);
 }  // namespace Kernel
diff --git a/dev/kernel/src/FS/HeFS+FileSystemParser.cc b/dev/kernel/src/FS/HeFS+FileSystemParser.cc
index b2d39dbe..9be598ac 100644
--- a/dev/kernel/src/FS/HeFS+FileSystemParser.cc
+++ b/dev/kernel/src/FS/HeFS+FileSystemParser.cc
@@ -47,7 +47,7 @@ namespace Detail {
                                                                    DriveTrait*     mnt,
                                                                    const Utf8Char* dir_name,
                                                                    const Utf8Char* file_name,
-                                                                   UInt8 kind, SizeT* cnt);
+                                                                   UInt8           kind);
 
   /***********************************************************************************/
   /// @brief Allocate a new index node->
@@ -111,40 +111,41 @@ namespace Detail {
                                                     const Lba& ind_start, Lba& start) {
     if (!mnt || !dir) return;
 
-    BOOL check_is_good = NO;
+    BOOL                       check_is_good = NO;
+    HEFS_INDEX_NODE_DIRECTORY* dir_tmp       = new HEFS_INDEX_NODE_DIRECTORY();
 
     while (YES) {
       mnt->fPacket.fPacketLba     = start;
       mnt->fPacket.fPacketSize    = sizeof(HEFS_INDEX_NODE_DIRECTORY);
-      mnt->fPacket.fPacketContent = dir;
+      mnt->fPacket.fPacketContent = dir_tmp;
       mnt->fInput(mnt->fPacket);
 
       if (!mnt->fPacket.fPacketGood) break;
 
-      if (dir->fNext != 0) {
+      if (dir_tmp->fNext != 0) {
         if (check_is_good) break;
 
-        start = dir->fNext;
+        start = dir_tmp->fNext;
 
         check_is_good = YES;
         continue;
-      } else if (dir->fPrev != 0) {
+      } else if (dir_tmp->fPrev != 0) {
         if (check_is_good) break;
 
-        start         = dir->fPrev;
+        start         = dir_tmp->fPrev;
         check_is_good = YES;
         continue;
       } else {
-        if (dir->fParent != 0) {
+        if (dir_tmp->fParent != 0) {
           if (check_is_good) break;
 
-          start         = dir->fParent;
+          start         = dir_tmp->fParent;
           check_is_good = YES;
           continue;
-        } else if (dir->fPrev != 0) {
+        } else if (dir_tmp->fPrev != 0) {
           if (check_is_good) break;
 
-          start         = dir->fPrev;
+          start         = dir_tmp->fPrev;
           check_is_good = YES;
           continue;
         } else {
@@ -159,6 +160,8 @@ namespace Detail {
       }
     }
 
+    delete dir_tmp;
+
     start += sizeof(HEFS_INDEX_NODE_DIRECTORY);
     if (start == 0) start = ind_start;
   }
@@ -302,7 +305,7 @@ namespace Detail {
           dirent->fModified   = 0UL;
           dirent->fEntryCount = 0UL;
 
-          dirent->fKind     = kHeFSFileKindDirectory;
+          dirent->fReserved = 0;
           dirent->fFlags    = flags;
           dirent->fChecksum = 0;
 
@@ -455,20 +458,13 @@ namespace Detail {
                                                                    DriveTrait*     mnt,
                                                                    const Utf8Char* dir_name,
                                                                    const Utf8Char* file_name,
-                                                                   UInt8 kind, SizeT* cnt) {
-    if (mnt && cnt) {
+                                                                   UInt8           kind) {
+    if (mnt) {
       if (root->fStartIND > root->fEndIND) return nullptr;
       if (root->fStartIN > root->fEndIN) return nullptr;
 
-      auto start = root->fStartIND;
-
-      auto start_cnt = 0UL;
-
-      HEFS_INDEX_NODE* node_arr = new HEFS_INDEX_NODE[*cnt];
-
-      if (!node_arr) {
-        return nullptr;
-      }
+      auto             start = root->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);
@@ -480,57 +476,37 @@ namespace Detail {
 
         mnt->fInput(mnt->fPacket);
 
-        if (hefsi_hash_64(dir_name) == dir->fHashPath && dir->fKind == kHeFSFileKindDirectory) {
-          HEFS_INDEX_NODE* node = new HEFS_INDEX_NODE();
+        (Void)(kout << hex_number(hefsi_hash_64(dir_name)) << kendl);
+        (Void)(kout << hex_number(dir->fHashPath) << kendl);
 
+        if (hefsi_hash_64(dir_name) == dir->fHashPath) {
           for (SizeT inode_index = 0UL; inode_index < kHeFSSliceCount; ++inode_index) {
-            if (dir->fINSlices[inode_index] != 0) {
-              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 &&
-                  ke_calculate_crc32((Char*) node, sizeof(HEFS_INDEX_NODE)) == node->fChecksum) {
-                node_arr[start_cnt] = *node;
-                ++start_cnt;
+            mnt->fPacket.fPacketLba     = dir->fINSlices[inode_index];
+            mnt->fPacket.fPacketSize    = sizeof(HEFS_INDEX_NODE);
+            mnt->fPacket.fPacketContent = node;
 
-                if (start_cnt > *cnt) {
-                  err_global_get() = kErrorSuccess;
-
-                  delete node;
-                  node = nullptr;
+            mnt->fInput(mnt->fPacket);
 
-                  delete dir;
-                  dir = nullptr;
+            (Void)(kout << hex_number(hefsi_hash_64(file_name)) << kendl);
+            (Void)(kout << hex_number(node->fHashPath) << kendl);
 
-                  return node_arr;
-                }
-              }
+            if (hefsi_hash_64(file_name) == node->fHashPath && node->fKind == kind) {
+              return node;
             }
           }
-
-          delete node;
-          node = nullptr;
         }
 
         hefsi_traverse_tree(dir, mnt, root->fStartIND, start);
-        if (start > root->fEndIND || start == 0) break;
       }
 
-      err_global_get() = kErrorSuccess;
-      delete dir;
+      delete node;
+      node = nullptr;
 
-      if (start_cnt == 0) {
-        delete[] node_arr;
-        node_arr = nullptr;
-      }
-
-      return node_arr;
+      delete dir;
+      dir = nullptr;
     }
 
-    kout << "Error: Failed to find index node->\r";
+    kout << "Error: Failed to find IN.\r";
 
     err_global_get() = kErrorFileNotFound;
 
@@ -580,13 +556,8 @@ namespace Detail {
 
               auto lba = dir->fINSlices[inode_index];
 
-              if (root->fStartBlock > (1ULL << 21)) {
-                node->fOffsetSliceLow  = (UInt32) (root->fStartBlock & 0xFFFFFFFF);
-                node->fOffsetSliceHigh = (UInt32) (root->fStartBlock >> 32);
-              } else {
-                node->fOffsetSliceLow  = (UInt32) root->fStartBlock;
-                node->fOffsetSliceHigh = 0UL;
-              }
+              node->fOffsetSliceLow  = (UInt32) (root->fStartBlock);
+              node->fOffsetSliceHigh = (UInt32) (root->fStartBlock >> 32);
 
               node->fChecksum = ke_calculate_crc32((Char*) node, sizeof(HEFS_INDEX_NODE));
 
@@ -982,8 +953,8 @@ _Output Bool HeFileSystemParser::CreateINode(_Input DriveTrait* mnt, _Input cons
 }
 
 _Output Bool HeFileSystemParser::INodeManip(_Input DriveTrait* mnt, VoidPtr block, SizeT block_sz,
-                                            const Utf8Char* dir, const UInt8 kind,
-                                            const Utf8Char* name, const BOOL in) {
+                                            const Utf8Char* dir, const Utf8Char* name,
+                                            const UInt8 kind, const BOOL in) {
   if (urt_string_len(dir) > kHeFSFileNameLen) {
     err_global_get() = kErrorDisk;
     return NO;
@@ -1011,43 +982,34 @@ _Output Bool HeFileSystemParser::INodeManip(_Input DriveTrait* mnt, VoidPtr bloc
   mnt->fInput(mnt->fPacket);
 
   if (!KStringBuilder::Equals(root->fMagic, kHeFSMagic) || root->fVersion != kHeFSVersion) {
+    (Void)(kout << "Invalid Boot Node, HeFS partition is invalid." << kendl);
+    mm_delete_heap((VoidPtr) root);
     err_global_get() = kErrorDisk;
     return NO;
   }
 
-  SizeT cnt   = block_sz / sizeof(HEFS_INDEX_NODE) + 1;
-  auto  nodes = Detail::hefsi_fetch_in(root, mnt, dir, name, kind, &cnt);
-
-  if (!nodes) return NO;
-
-  for (SizeT i = 0UL; i < cnt; ++i) {
-    auto& start = nodes[i];
-
-    kout << hex_number(start.fHashPath) << kendl;
-    kout << hex_number(start.fOffsetSliceLow) << kendl;
+  auto start = Detail::hefsi_fetch_in(root, mnt, dir, name, kind);
 
-    if (!start.fHashPath || !start.fOffsetSliceLow) continue;
+  if (start) {
+    (Void)(kout << hex_number(start->fHashPath) << kendl);
+    (Void)(kout << hex_number(start->fOffsetSliceLow) << kendl);
 
-    mnt->fPacket.fPacketLba     = start.fOffsetSliceLow + start.fOffsetSliceHigh;
-    mnt->fPacket.fPacketSize    = kHeFSBlockLen;
-    mnt->fPacket.fPacketContent = block;
+    if (start->fOffsetSliceLow) {
+      mnt->fPacket.fPacketLba     = start->fOffsetSliceLow | start->fOffsetSliceHigh << 32;
+      mnt->fPacket.fPacketSize    = block_sz;
+      mnt->fPacket.fPacketContent = block;
 
-    if (in) {
-      mnt->fInput(mnt->fPacket);
-    } else {
-      mnt->fOutput(mnt->fPacket);
+      if (in) {
+        mnt->fInput(mnt->fPacket);
+      } else {
+        mnt->fOutput(mnt->fPacket);
+      }
     }
-
-    mm_delete_heap((VoidPtr) root);
-    delete[] nodes;
-    return mnt->fPacket.fPacketGood == YES;
   }
 
-  delete[] nodes;
-  nodes = nullptr;
-
   mm_delete_heap((VoidPtr) root);
-  return NO;
+  delete start;
+  return YES;
 }
 
 /// @brief Create a new file on the disk.
@@ -1165,16 +1127,17 @@ Boolean fs_init_hefs(Void) {
 
   parser.Format(&kMountPoint, kHeFSEncodingFlagsUTF8, kHeFSDefaultVolumeName);
 
-  MUST_PASS(parser.CreateINode(&kMountPoint, kHeFSEncodingFlagsBinary | kHeFSFlagsReadOnly,
-                               u8"/boot", u8"ジェット警察.txt", kHeFSFileKindRegular));
+  MUST_PASS(parser.CreateINode(&kMountPoint, kHeFSEncodingFlagsBinary | kHeFSFlagsReadOnly, u8"/boot",
+                               u8"bootinfo.cfg", kHeFSFileKindRegular));
+
+  Utf8Char contents_1[kHeFSBlockLen] = {0};
 
-  Utf8Char contents_1[kHeFSBlockLen] = {u8"ロケットにはジエットエンジン\r\0"};
+  urt_set_memory(contents_1, 0, kHeFSBlockLen);
 
-  MUST_PASS(parser.INodeManip(&kMountPoint, contents_1, kHeFSBlockLen, u8"/boot",
-                              kHeFSFileKindRegular, u8"ジェット警察.txt", NO));
+  MUST_PASS(parser.INodeManip(&kMountPoint, contents_1, kHeFSBlockLen, u8"/boot", u8"bootinfo.cfg",
+                              kHeFSFileKindRegular, YES));
 
-  MUST_PASS(parser.INodeManip(&kMountPoint, contents_1, kHeFSBlockLen, u8"/boot",
-                              kHeFSFileKindRegular, u8"ジェット警察.txt", YES));
+  kout8 << text << kendl8;
 
   return YES;
 }
diff --git a/dev/kernel/src/MemoryMgr.cc b/dev/kernel/src/MemoryMgr.cc
index 001f970a..9b7bea43 100644
--- a/dev/kernel/src/MemoryMgr.cc
+++ b/dev/kernel/src/MemoryMgr.cc
@@ -219,7 +219,7 @@ _Output Int32 mm_delete_heap(VoidPtr heap_ptr) {
     heap_info_ptr->fMagic     = 0;
     heap_info_ptr->fPad       = 0;
 
-    (Void)(kout << "Address has been successfully freed: " << hex_number((UIntPtr) heap_info_ptr)
+    (Void)(kout << "Freed heap address: " << hex_number(reinterpret_cast<UIntPtr>(heap_info_ptr))
                 << kendl);
 
     PTEWrapper page_wrapper(
diff --git a/dev/kernel/src/UtfUtils.cc b/dev/kernel/src/UtfUtils.cc
index 079efb7b..ed0e4591 100644
--- a/dev/kernel/src/UtfUtils.cc
+++ b/dev/kernel/src/UtfUtils.cc
@@ -15,6 +15,16 @@ Size urt_string_len(const Utf8Char* str) {
   return len;
 }
 
+Void urt_set_memory(const voidPtr src, UInt32 dst, Size len) {
+  Utf8Char* srcChr = reinterpret_cast<Utf8Char*>(src);
+  Size      index  = 0;
+
+  while (index < len) {
+    srcChr[index] = dst;
+    ++index;
+  }
+}
+
 Int urt_copy_memory(const voidPtr src, voidPtr dst, Size len) {
   Utf8Char* srcChr  = reinterpret_cast<Utf8Char*>(src);
   Utf8Char* dstChar = reinterpret_cast<Utf8Char*>(dst);
-- 
cgit v1.2.3


From 2bbe51e66f96f4f50f7d1de71a5e65e5de213350 Mon Sep 17 00:00:00 2001
From: Amlal <amlal@nekernel.org>
Date: Sun, 11 May 2025 08:44:23 +0200
Subject: feat(kernel): HeFS TeX specs have been updated, and cleaned up the
 official filesystem implementation, with a bootinfo.cfg being added too.

why:
 - The LaTeX specs were outdated, some elements had to be reseen.

also:
 - Removed useless part of the logger, for the panic message.

Signed-off-by: Amlal <amlal@nekernel.org>
---
 dev/kernel/FSKit/HeFS.h                    | 14 ++------------
 dev/kernel/HALKit/AMD64/HalDebugOutput.cc  | 14 +-------------
 dev/kernel/src/FS/HeFS+FileSystemParser.cc | 29 ++++++++++++++++++++++++-----
 dev/kernel/src/UtfUtils.cc                 |  2 +-
 docs/tex/hefs.tex                          |  4 ++--
 setup_x64.sh                               |  3 +++
 6 files changed, 33 insertions(+), 33 deletions(-)

(limited to 'dev/kernel/FSKit')

diff --git a/dev/kernel/FSKit/HeFS.h b/dev/kernel/FSKit/HeFS.h
index 85421069..bf1bf867 100644
--- a/dev/kernel/FSKit/HeFS.h
+++ b/dev/kernel/FSKit/HeFS.h
@@ -25,7 +25,7 @@
 #define kHeFSFileNameLen (256U)
 #define kHeFSPartNameLen (128U)
 
-#define kHeFSMinimumDiskSize (gib_cast(1))
+#define kHeFSMinimumDiskSize (gib_cast(8))
 
 #define kHeFSDefaultVolumeName u8"HeFS Volume"
 
@@ -38,7 +38,6 @@ struct HEFS_BOOT_NODE;
 struct HEFS_INDEX_NODE;
 struct HEFS_INDEX_NODE_DIRECTORY;
 struct HEFS_JOURNAL_NODE;
-struct HEFS_SLICE_NODE;
 
 enum : UInt8 {
   kHeFSHardDrive         = 0xC0,  // Hard Drive
@@ -135,12 +134,6 @@ struct PACKED HEFS_BOOT_NODE final {
 inline constexpr ATime kHeFSTimeInvalid = 0x0000000000000000;
 inline constexpr ATime kHeFSTimeMax     = 0xFFFFFFFFFFFFFFFF - 1;
 
-/// @brief INode Slice structure, organized like a range container.
-struct PACKED HEFS_SLICE_NODE {
-  UInt32 fBase;
-  UInt32 fLength;
-};
-
 /// @brief Journal Node structure
 /// @param fHashPath target hash path
 /// @param fStatus target status
@@ -178,10 +171,7 @@ struct PACKED HEFS_INDEX_NODE final {
   UInt32 fOffsetSliceLow;
   UInt32 fOffsetSliceHigh;
 
-  ATTRIBUTE(deprecated)
-  HEFS_SLICE_NODE fSlices[kHeFSSliceCount];  /// @brief block slice, unused as of current HeFS.
-
-  Char fPad[309];
+  Char fPad[437];
 };
 
 enum {
diff --git a/dev/kernel/HALKit/AMD64/HalDebugOutput.cc b/dev/kernel/HALKit/AMD64/HalDebugOutput.cc
index 71dee911..bd8fe734 100644
--- a/dev/kernel/HALKit/AMD64/HalDebugOutput.cc
+++ b/dev/kernel/HALKit/AMD64/HalDebugOutput.cc
@@ -108,7 +108,6 @@ EXTERN_C void ke_io_write(IDeviceObject<const Char*>* obj, const Char* bytes) {
   len   = rt_string_len(bytes);
 
   STATIC SizeT x = kFontSizeX, y = kFontSizeY;
-  STATIC BOOL  not_important = YES;
 
   while (index < len) {
     if (bytes[index] == '\r') HAL::rt_out8(Detail::kPort, '\r');
@@ -119,18 +118,7 @@ EXTERN_C void ke_io_write(IDeviceObject<const Char*>* obj, const Char* bytes) {
     tmp_str[0] = bytes[index];
     tmp_str[1] = 0;
 
-    if (bytes[index] == '*') {
-      if (not_important)
-        not_important = NO;
-      else
-        not_important = YES;
-
-      ++index;
-
-      continue;
-    }
-
-    fb_render_string(tmp_str, y, x, not_important ? RGB(0xff, 0xff, 0xff) : RGB(0xff, 0x00, 0x00));
+    fb_render_string(tmp_str, y, x, RGB(0xff, 0xff, 0xff));
 
     if (bytes[index] == '\r') {
       y += kFontSizeY;
diff --git a/dev/kernel/src/FS/HeFS+FileSystemParser.cc b/dev/kernel/src/FS/HeFS+FileSystemParser.cc
index fa82320f..e91040b2 100644
--- a/dev/kernel/src/FS/HeFS+FileSystemParser.cc
+++ b/dev/kernel/src/FS/HeFS+FileSystemParser.cc
@@ -800,8 +800,8 @@ _Output Bool HeFileSystemParser::Format(_Input _Output DriveTrait* mnt, _Input c
   /// @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 dir_max   = max_lba / 5;  // 20% for directory inodes
-  const SizeT inode_max = max_lba / 3;  // 30% for inodes
+  const SizeT dir_max   = max_lba / 20;  // 20% for directory inodes
+  const SizeT inode_max = max_lba / 30;  // 30% for inodes
 
   root->fStartIND = mnt->fLbaStart + kHeFSINDStartOffset;
   root->fEndIND   = root->fStartIND + dir_max;
@@ -954,7 +954,7 @@ _Output Bool HeFileSystemParser::CreateINode(_Input DriveTrait* mnt, _Input cons
 
 _Output Bool HeFileSystemParser::INodeManip(_Input DriveTrait* mnt, VoidPtr block, SizeT block_sz,
                                             const Utf8Char* dir, const Utf8Char* name,
-                                            const UInt8 kind, const BOOL in) {
+                                            const UInt8 kind, const BOOL is_input) {
   if (urt_string_len(dir) > kHeFSFileNameLen) {
     err_global_get() = kErrorDisk;
     return NO;
@@ -999,7 +999,7 @@ _Output Bool HeFileSystemParser::INodeManip(_Input DriveTrait* mnt, VoidPtr bloc
       mnt->fPacket.fPacketSize    = block_sz;
       mnt->fPacket.fPacketContent = block;
 
-      if (in) {
+      if (is_input) {
         mnt->fInput(mnt->fPacket);
       } else {
         mnt->fOutput(mnt->fPacket);
@@ -1137,7 +1137,26 @@ Boolean fs_init_hefs(Void) {
   MUST_PASS(parser.INodeManip(&kMountPoint, contents_1, kHeFSBlockLen, u8"/boot", u8"bootinfo.cfg",
                               kHeFSFileKindRegular, YES));
 
-  kout8 << contents_1 << kendl8;
+  if (*contents_1 != u'\0') {
+    (Void)(kout << "/boot/bootinfo.cfg:" << kendl);
+    (Void)(kout8 << contents_1 << kendl8);
+  } else {
+    auto src =
+      u8"[boot]\r"
+      u8"path=bootz.efi\r"
+      u8"name=BootZ\r"
+      u8"[kernel]\r"
+      u8"path=krnl.efi\r"
+      u8"name=NeKernel\r"
+      u8"[chk]\r"
+      u8"path=chk.efi\r"
+      u8"name=SysChk\r";
+    
+    urt_copy_memory((VoidPtr) src, contents_1, urt_string_len(src));
+    
+    MUST_PASS(parser.INodeManip(&kMountPoint, contents_1, kHeFSBlockLen, u8"/boot",
+                                u8"bootinfo.cfg", kHeFSFileKindRegular, NO));
+  }
 
   return YES;
 }
diff --git a/dev/kernel/src/UtfUtils.cc b/dev/kernel/src/UtfUtils.cc
index ed0e4591..11d7471a 100644
--- a/dev/kernel/src/UtfUtils.cc
+++ b/dev/kernel/src/UtfUtils.cc
@@ -10,7 +10,7 @@ namespace Kernel {
 Size urt_string_len(const Utf8Char* str) {
   SizeT len{0};
 
-  while (str[len] != u'\0') ++len;
+  while (str[len] != u8'\0') ++len;
 
   return len;
 }
diff --git a/docs/tex/hefs.tex b/docs/tex/hefs.tex
index e5a08049..bc152293 100644
--- a/docs/tex/hefs.tex
+++ b/docs/tex/hefs.tex
@@ -26,9 +26,9 @@ The High-throughput Extended File System (HeFS) is a custom filesystem tailored
 \texttt{kHeFSBlockLen} & 512 bytes \\
 \texttt{kHeFSFileNameLen} & 256 characters \\
 \texttt{kHeFSPartNameLen} & 128 characters \\
-\texttt{kHeFSMinimumDiskSize} & 1 GiB \\
+\texttt{kHeFSMinimumDiskSize} & 8 GiB \\
 \texttt{kHeFSDefaultVolumeName} & "HeFS Volume" \\
-\texttt{kHeFSINDStartOffset} & Offset after boot + dir nodes \\
+\texttt{kHeFSINDStartOffset} & Offset after boot node \\
 \texttt{kHeFSSearchAllStr} & "\*" (wildcard string) \\
 \hline
 \end{longtable}
diff --git a/setup_x64.sh b/setup_x64.sh
index da2027a1..6afc1633 100755
--- a/setup_x64.sh
+++ b/setup_x64.sh
@@ -5,6 +5,9 @@
 # 04/05/25: Improve and fix script.
 
 cd dev/user
+cd src
+make sci_asm_io_x64
+cd ..
 btb user.json
 cd ../boot
 make -f amd64-desktop.make efi
-- 
cgit v1.2.3