kernel: filesystem+vmem: don't be verbose on the allocator when we don't need it.

details:
 - Reworked HeFS traversal algorithm, fixing last parts of HeFS regarding IND allocation.

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

7 files changed, 86 insertions, 107 deletions

diff --git a/compile_flags.txt b/compile_flags.txt
index be8085bd..b37b28ae 100644
--- a/compile_flags.txt
+++ b/compile_flags.txt
@@ -30,6 +30,6 @@
 -D__FSKIT_INCLUDES_HEFS__
 -D__FSKIT_INCLUDES_NEFS__
 -D__FSKIT_INCLUDES_EXT2__
--D__NE_VEPM__
--DBOOTZ_VEPM_SUPPORT
+-D__NE_VIRTUAL_MEMORY_SUPPORT__
+-DBOOTZ_GPT_SUPPORT
 -D__x86_64__
\ No newline at end of file
diff --git a/dev/boot/BootKit/BootKit.h b/dev/boot/BootKit/BootKit.h
index d10ce0de..715f6426 100644
--- a/dev/boot/BootKit/BootKit.h
+++ b/dev/boot/BootKit/BootKit.h
@@ -225,16 +225,16 @@ class BDiskFormatFactory final {
 
     return true;
 #else
-    GPT_PARTITION_TABLE gpt_part{};
+    GPT_PARTITION_TABLE* gpt_part = (GPT_PARTITION_TABLE*) RTL_ALLOCA(sizeof(GPT_PARTITION_TABLE));
 
     fDiskDev.Leak().mBase = (kGPTPartitionTableLBA);
     fDiskDev.Leak().mSize = sizeof(GPT_PARTITION_TABLE);
 
-    fDiskDev.Read((Char*) &gpt_part, sizeof(GPT_PARTITION_TABLE));
+    fDiskDev.Read((Char*) gpt_part, sizeof(GPT_PARTITION_TABLE));
 
     BootTextWriter writer;
 
-    if (StrCmp(gpt_part.Signature, kMagicGPT) == 0) {
+    if (StrCmp(gpt_part->Signature, kMagicGPT) == 0) {
       writer.Write("BootZ: GPT Partition found.\r");
       return true;
     }
@@ -256,74 +256,76 @@ class BDiskFormatFactory final {
 template <typename BootDev>
 inline Boolean BDiskFormatFactory<BootDev>::Format(const Char* part_name) {
 #if defined(BOOTZ_EPM_SUPPORT)
-  EPM_PART_BLOCK epm_boot{};
+  EPM_PART_BLOCK* epm_boot = (EPM_PART_BLOCK*) RTL_ALLOCA(sizeof(EPM_PART_BLOCK));
 
   const auto kFsName    = "HeFS";
   const auto kBlockName = "OS (EPM)";
 
-  epm_boot.FsVersion = 0;
-  epm_boot.LbaStart  = sizeof(EPM_PART_BLOCK);
-  epm_boot.LbaEnd    = fDiskDev.GetDiskSize() - 1;
-  epm_boot.SectorSz  = BootDev::kSectorSize;
-  epm_boot.Kind      = kEPMNeKernel;
-  epm_boot.NumBlocks = 1;
+  epm_boot->FsVersion = 0;
+  epm_boot->LbaStart  = sizeof(EPM_PART_BLOCK);
+  epm_boot->LbaEnd    = fDiskDev.GetDiskSize() - 1;
+  epm_boot->SectorSz  = BootDev::kSectorSize;
+  epm_boot->Kind      = kEPMNeKernel;
+  epm_boot->NumBlocks = 1;
 
-  epm_boot.Guid = kEPMNilGuid;
+  epm_boot->Guid = kEPMNilGuid;
 
-  CopyMem(epm_boot.Fs, reinterpret_cast<VoidPtr>(const_cast<Char*>(kFsName)), StrLen(kFsName));
-  CopyMem(epm_boot.Name, reinterpret_cast<VoidPtr>(const_cast<Char*>(kBlockName)),
+  CopyMem(epm_boot->Fs, reinterpret_cast<VoidPtr>(const_cast<Char*>(kFsName)), StrLen(kFsName));
+  CopyMem(epm_boot->Name, reinterpret_cast<VoidPtr>(const_cast<Char*>(kBlockName)),
           StrLen(kBlockName));
-  CopyMem(epm_boot.Magic, reinterpret_cast<VoidPtr>(const_cast<Char*>(kEPMMagic)),
+  CopyMem(epm_boot->Magic, reinterpret_cast<VoidPtr>(const_cast<Char*>(kEPMMagic)),
           StrLen(kEPMMagic));
 
   fDiskDev.Leak().mBase = kEPMBootBlockLba;  // always always resies at zero block.
   fDiskDev.Leak().mSize = sizeof(EPM_PART_BLOCK);
 
-  fDiskDev.Write((Char*) &epm_boot, sizeof(EPM_PART_BLOCK));
+  fDiskDev.Write((Char*) epm_boot, sizeof(EPM_PART_BLOCK));
 
   BootTextWriter writer;
   writer.Write(L"BootZ: Drive is EPM formatted.\r");
-#elif defined(BOOTZ_VEPM_SUPPORT)
+#elif defined(BOOTZ_GPT_SUPPORT)
   NE_UNUSED(part_name);
 
-  GPT_PARTITION_TABLE gpt_part{};
+  GPT_PARTITION_TABLE* gpt_part = (GPT_PARTITION_TABLE*) RTL_ALLOCA(sizeof(GPT_PARTITION_TABLE));
 
-  CopyMem(gpt_part.Signature, reinterpret_cast<VoidPtr>(const_cast<Char*>(kMagicGPT)),
+  CopyMem(gpt_part->Signature, reinterpret_cast<VoidPtr>(const_cast<Char*>(kMagicGPT)),
           StrLen(kMagicGPT));
 
-  gpt_part.Revision   = 0x00010000;
-  gpt_part.HeaderSize = sizeof(GPT_PARTITION_TABLE);
+  gpt_part->Revision   = 0x00010000;
+  gpt_part->HeaderSize = sizeof(GPT_PARTITION_TABLE);
 
-  gpt_part.CRC32 = 0x00000000;
+  gpt_part->CRC32 = 0x00000000;
 
-  gpt_part.Reserved1     = 0x00000000;
-  gpt_part.LBAHeader     = 0x00000000;
-  gpt_part.LBAAltHeader  = 0x00000000;
-  gpt_part.FirstGPTEntry = 0x00000000;
-  gpt_part.LastGPTEntry  = 0x00000000;
+  gpt_part->Reserved1     = 0x00000000;
+  gpt_part->LBAHeader     = 0x00000000;
+  gpt_part->LBAAltHeader  = 0x00000000;
+  gpt_part->FirstGPTEntry = 0x00000000;
+  gpt_part->LastGPTEntry  = 0x00000000;
 
-  gpt_part.Guid.Data1 = 0x00000000;
-  gpt_part.Guid.Data2 = 0x0000;
-  gpt_part.Guid.Data3 = 0x0000;
+  gpt_part->Guid.Data1 = 0x00000000;
+  gpt_part->Guid.Data2 = 0x0000;
+  gpt_part->Guid.Data3 = 0x0000;
 
-  SetMem(gpt_part.Guid.Data4, 0, 8);
+  SetMem(gpt_part->Guid.Data4, 0, 8);
 
-  gpt_part.Revision = 0x00010000;
+  gpt_part->Revision = 0x00010000;
 
-  gpt_part.StartingLBA         = 0x00000000;
-  gpt_part.NumPartitionEntries = 0x00000000;
-  gpt_part.SizeOfEntries       = 0x00000000;
-  gpt_part.CRC32PartEntry      = 0x00000000;
+  gpt_part->StartingLBA         = 0x00000000;
+  gpt_part->NumPartitionEntries = 0x00000000;
+  gpt_part->SizeOfEntries       = 0x00000000;
+  gpt_part->CRC32PartEntry      = 0x00000000;
 
-  SetMem(gpt_part.Reserved2, 0, kSectorAlignGPT_PartTbl);
+  SetMem(gpt_part->Reserved2, 0, kSectorAlignGPT_PartTbl);
 
   fDiskDev.Leak().mBase = kGPTPartitionTableLBA;  // always always resies at zero block.
   fDiskDev.Leak().mSize = sizeof(GPT_PARTITION_TABLE);
 
-  fDiskDev.Write((Char*) &gpt_part, sizeof(GPT_PARTITION_TABLE));
+  fDiskDev.Write((Char*) gpt_part, sizeof(GPT_PARTITION_TABLE));
 
   BootTextWriter writer;
   writer.Write(L"BootZ: Drive is GPT formatted.\r");
+#else
+  NE_UNUSED(part_name);
 #endif
 
   return YES;
diff --git a/dev/boot/modules/SysChk/SysChk.cc b/dev/boot/modules/SysChk/SysChk.cc
index c93ef83b..1c5255fb 100644
--- a/dev/boot/modules/SysChk/SysChk.cc
+++ b/dev/boot/modules/SysChk/SysChk.cc
@@ -24,7 +24,7 @@
 // Makes the compiler shut up.
 #ifndef kMachineModel
 #define kMachineModel "OS"
-#endif  // !kMachineModel
+#endif // !kMachineModel
 
 EXTERN_C Int32 SysChkModuleMain(Kernel::HEL::BootInfoHeader* handover) {
   fw_init_efi((EfiSystemTable*) handover->f_FirmwareCustomTables[1]);
diff --git a/dev/kernel/HALKit/AMD64/HalPagingMgrAMD64.cc b/dev/kernel/HALKit/AMD64/HalPagingMgrAMD64.cc
index b6176e39..7a3e776f 100644
--- a/dev/kernel/HALKit/AMD64/HalPagingMgrAMD64.cc
+++ b/dev/kernel/HALKit/AMD64/HalPagingMgrAMD64.cc
@@ -37,14 +37,18 @@ namespace Detail {
 /// \param pte Page Table Entry pointer.
 /***********************************************************************************/
 STATIC Void mmi_page_status(Detail::PTE* pte) {
+  NE_UNUSED(pte);
+
+#ifdef __NE_VERBOSE_BITMAP__
   (Void)(kout << (pte->Present ? "Present" : "Not Present") << kendl);
   (Void)(kout << (pte->Wr ? "W/R" : "Not W/R") << kendl);
   (Void)(kout << (pte->Nx ? "NX" : "Not NX") << kendl);
   (Void)(kout << (pte->User ? "User" : "Not User") << kendl);
   (Void)(kout << (pte->Pcd ? "Not Cached" : "Cached") << kendl);
   (Void)(kout << (pte->Accessed ? "Accessed" : "Not Accessed") << kendl);
-  (Void)(kout << hex_number(pte->PhysicalAddress) << kendl);
   (Void)(kout << (pte->ProtectionKey ? "Protected" : "Not Protected/PKU Disabled") << kendl);
+  (Void)(kout << "Physical Address: " << hex_number(pte->PhysicalAddress) << kendl);
+#endif
 }
 
 /***********************************************************************************/
diff --git a/dev/kernel/src/BitMapMgr.cc b/dev/kernel/src/BitMapMgr.cc
index cc5797b3..7cbcf376 100644
--- a/dev/kernel/src/BitMapMgr.cc
+++ b/dev/kernel/src/BitMapMgr.cc
@@ -136,6 +136,7 @@ namespace HAL {
           return;
         }
 
+#ifdef __NE_VERBOSE_BITMAP__
         (Void)(kout << "Magic: " << hex_number(ptr_bit_set[kBitMapMagIdx]) << kendl);
         (Void)(kout << "Is Allocated? " << (ptr_bit_set[kBitMapUsedIdx] ? "YES" : "NO") << kendl);
         (Void)(kout << "Size of BitMap (B): " << number(ptr_bit_set[kBitMapSizeIdx]) << kendl);
@@ -148,6 +149,7 @@ namespace HAL {
         (Void)(kout << "Size of BitMap (TIB): " << number(TIB(ptr_bit_set[kBitMapSizeIdx]))
                     << kendl);
         (Void)(kout << "BitMap Address: " << hex_number((UIntPtr) ptr_bit_set) << kendl);
+#endif
       }
     };
   }  // namespace Detail
diff --git a/dev/kernel/src/FS/HeFS.cc b/dev/kernel/src/FS/HeFS.cc
index 6809f4b4..e3dcb699 100644
--- a/dev/kernel/src/FS/HeFS.cc
+++ b/dev/kernel/src/FS/HeFS.cc
@@ -88,6 +88,7 @@ namespace Detail {
     } else {
       if (hop_watch) {
         err_global_get() = kErrorDisk;
+        return;
       }
 
       start += kHeFSINDStartOffset;
@@ -100,12 +101,13 @@ namespace Detail {
   /// @brief Rotate the RB-Tree to the left.
   /// @internal
   /***********************************************************************************/
-  STATIC ATTRIBUTE(unused) _Output Void
-      hefsi_rotate_left(HEFS_INDEX_NODE_DIRECTORY* dir, Lba& start, DriveTrait* mnt) {
+  STATIC ATTRIBUTE(unused) _Output Void hefsi_rotate_tree(Lba& start, DriveTrait* mnt, Bool left) {
+    if (!start || !mnt) return;
+
     HEFS_INDEX_NODE_DIRECTORY* parent =
         (HEFS_INDEX_NODE_DIRECTORY*) RTL_ALLOCA(sizeof(HEFS_INDEX_NODE_DIRECTORY));
 
-    mnt->fPacket.fPacketLba     = dir->fParent;
+    mnt->fPacket.fPacketLba     = start;
     mnt->fPacket.fPacketSize    = sizeof(HEFS_INDEX_NODE_DIRECTORY);
     mnt->fPacket.fPacketContent = parent;
 
@@ -120,63 +122,33 @@ namespace Detail {
 
     mnt->fInput(mnt->fPacket);
 
-    dir->fParent    = parent->fParent;
-    parent->fParent = start;
-    parent->fNext   = dir->fChild;
-    dir->fChild     = dir->fParent;
-
-    if (parent->fParent == 0 || dir->fParent == 0) return;
-
-    mnt->fPacket.fPacketLba     = parent->fParent;
-    mnt->fPacket.fPacketSize    = sizeof(HEFS_INDEX_NODE_DIRECTORY);
-    mnt->fPacket.fPacketContent = grand_parent;
-
-    mnt->fOutput(mnt->fPacket);
+    if (parent->fParent == 0) return;
 
-    mnt->fPacket.fPacketLba     = dir->fParent;
-    mnt->fPacket.fPacketSize    = sizeof(HEFS_INDEX_NODE_DIRECTORY);
-    mnt->fPacket.fPacketContent = parent;
-
-    mnt->fOutput(mnt->fPacket);
-
-    kout << "Rotate tree to left.\r";
-  }
-
-  /***********************************************************************************/
-  /// @brief Rotate the RB-Tree to the right.
-  /// @internal
-  /***********************************************************************************/
-  STATIC ATTRIBUTE(unused) _Output Void
-      hefsi_rotate_right(HEFS_INDEX_NODE_DIRECTORY* dir, Lba& start, DriveTrait* mnt) {
-    HEFS_INDEX_NODE_DIRECTORY* parent =
+    HEFS_INDEX_NODE_DIRECTORY* cousin =
         (HEFS_INDEX_NODE_DIRECTORY*) RTL_ALLOCA(sizeof(HEFS_INDEX_NODE_DIRECTORY));
 
-    mnt->fPacket.fPacketLba     = dir->fParent;
+    mnt->fPacket.fPacketLba     = left ? grand_parent->fPrev : grand_parent->fNext;
     mnt->fPacket.fPacketSize    = sizeof(HEFS_INDEX_NODE_DIRECTORY);
-    mnt->fPacket.fPacketContent = parent;
+    mnt->fPacket.fPacketContent = cousin;
 
     mnt->fInput(mnt->fPacket);
 
-    parent->fParent = dir->fParent;
-    dir->fParent    = parent->fParent;
-    dir->fNext      = parent->fChild;
-    parent->fChild  = start;
+    parent->fParent = cousin->fParent;
+    cousin->fChild  = start;
 
-    mnt->fPacket.fPacketLba     = dir->fParent;
+    mnt->fPacket.fPacketLba     = parent->fParent;
     mnt->fPacket.fPacketSize    = sizeof(HEFS_INDEX_NODE_DIRECTORY);
-    mnt->fPacket.fPacketContent = parent;
+    mnt->fPacket.fPacketContent = grand_parent;
 
     mnt->fOutput(mnt->fPacket);
 
-    dir->fColor = kHeFSBlack;
-
     mnt->fPacket.fPacketLba     = start;
     mnt->fPacket.fPacketSize    = sizeof(HEFS_INDEX_NODE_DIRECTORY);
-    mnt->fPacket.fPacketContent = dir;
+    mnt->fPacket.fPacketContent = parent;
 
     mnt->fOutput(mnt->fPacket);
 
-    kout << "Rotate tree to right.\r";
+    kout << "Rotate tree has been done.\r";
   }
 
   /// @brief Get the index node size.
@@ -243,7 +215,7 @@ namespace Detail {
   }
 
   /// @brief Alllocate IND for boot node->
-  STATIC _Output BOOL hefsi_allocate_index_directory_node(HEFS_BOOT_NODE* root, DriveTrait* mnt,
+  STATIC _Output BOOL hefsi_allocate_index_node_directory(HEFS_BOOT_NODE* root, DriveTrait* mnt,
                                                           const Utf8Char* dir_name,
                                                           UInt16          flags) noexcept {
     if (urt_string_len(dir_name) >= kHeFSFileNameLen) {
@@ -286,23 +258,24 @@ namespace Detail {
           dirent->fFlags    = flags;
           dirent->fChecksum = 0;
 
-          dirent->fChecksum = ke_calculate_crc32((Char*) dirent, sizeof(HEFS_INDEX_NODE_DIRECTORY));
-
           dirent->fEntryCount = 0;
 
-          dirent->fNext = tmpdir->fNext;
-          dirent->fPrev = tmpdir->fPrev;
+          dirent->fNext   = tmpdir->fNext;
+          dirent->fPrev   = tmpdir->fPrev;
+          dirent->fParent = tmpdir->fParent;
+          dirent->fChild  = tmpdir->fChild;
+          dirent->fColor = tmpdir->fColor;
+
+          if (dirent->fColor < kHeFSRed) {
+            dirent->fColor = kHeFSBlack;
+          }
 
           if (dirent->fPrev == 0) {
             dirent->fPrev = root->fStartIND;
           }
 
           if (dirent->fNext == 0) {
-            if (start < root->fEndIND) {
-              dirent->fNext = start + sizeof(HEFS_INDEX_NODE_DIRECTORY);
-            } else {
-              dirent->fNext = 0;
-            }
+            dirent->fNext = start + sizeof(HEFS_INDEX_NODE_DIRECTORY);
           }
 
           if (tmpdir->fParent == 0) {
@@ -334,9 +307,6 @@ namespace Detail {
             dirent->fChild = child;
 
             if (child > root->fEndIND) dirent->fChild = root->fEndIND;
-          } else {
-            dirent->fColor = tmpdir->fColor;
-            dirent->fChild = tmpdir->fChild;
           }
 
           for (SizeT index = 0UL; index < (kHeFSBlockCount * 2); index += 2) {
@@ -344,6 +314,8 @@ namespace Detail {
             dirent->fIndexNode[index + 1] = 0UL;
           }
 
+          dirent->fChecksum = ke_calculate_crc32((Char*) dirent, sizeof(HEFS_INDEX_NODE_DIRECTORY));
+
           mnt->fPacket.fPacketLba     = start;
           mnt->fPacket.fPacketSize    = sizeof(HEFS_INDEX_NODE_DIRECTORY);
           mnt->fPacket.fPacketContent = dirent;
@@ -647,7 +619,7 @@ namespace Detail {
           continue;
         } else {
           if (dir_parent->fNext == start) {
-            hefsi_rotate_left(dir_parent, start, mnt);
+            hefsi_rotate_tree(start, mnt, YES);
             hefsi_traverse_tree(dir_parent, start, YES);
 
             if (start > root->fEndIND || start == 0) break;
@@ -669,7 +641,7 @@ namespace Detail {
             return NO;
           }
 
-          hefsi_rotate_right(dir, start, mnt);
+          hefsi_rotate_tree(start, mnt, NO);
         }
 
         hefsi_traverse_tree(dir, start, YES);
@@ -760,10 +732,10 @@ _Output Bool HeFileSystemParser::Format(_Input _Output DriveTrait* drive, _Input
   root->fStartIND = drive->fLbaStart + kHeFSINDStartOffset;
   root->fEndIND   = root->fStartIND + dir_max;
 
-  root->fStartIN = root->fEndIND - kHeFSINDStartOffset;
+  root->fStartIN = root->fEndIND + kHeFSINDStartOffset;
   root->fEndIN   = root->fStartIN + inode_max;
 
-  constexpr SizeT kHeFSPreallocateCount = 0x2UL;
+  constexpr SizeT kHeFSPreallocateCount = 0x7UL;
 
   root->fINDCount = kHeFSPreallocateCount;
 
@@ -807,8 +779,7 @@ _Output Bool HeFileSystemParser::Format(_Input _Output DriveTrait* drive, _Input
   }
 
   const Utf8Char* kFileMap[kHeFSPreallocateCount] = {
-      u8"/",
-      u8"/boot",
+      u8"/", u8"/boot", u8"/system", u8"/network", u8"/devices", u8"/media", u8"/vm",
   };
 
   for (SizeT i = 0; i < kHeFSPreallocateCount; ++i) {
@@ -858,7 +829,7 @@ _Output Bool HeFileSystemParser::CreateDirectory(_Input DriveTrait* drive, _Inpu
 
   urt_copy_memory((VoidPtr) dir, name, urt_string_len(dir) + 1);
 
-  if (Detail::hefsi_allocate_index_directory_node(root, drive, name, flags)) {
+  if (Detail::hefsi_allocate_index_node_directory(root, drive, name, flags)) {
     mm_delete_heap((VoidPtr) root);
     delete[] name;
     return YES;
@@ -898,7 +869,7 @@ _Output Bool HeFileSystemParser::CreateFile(_Input DriveTrait* drive, _Input con
 
   drive->fInput(drive->fPacket);
 
-  Detail::hefsi_fetch_index_node_directory(root, drive, dir);
+  if (!Detail::hefsi_fetch_index_node_directory(root, drive, dir)->fCreated) return NO;
 
   if (KStringBuilder::Equals(name, kHeFSSearchAllStr)) {
     kout << "Error: Invalid file name.\r";
diff --git a/dev/kernel/src/PageMgr.cc b/dev/kernel/src/PageMgr.cc
index 7e385f26..f60fa57a 100644
--- a/dev/kernel/src/PageMgr.cc
+++ b/dev/kernel/src/PageMgr.cc
@@ -30,9 +30,9 @@ PTEWrapper::~PTEWrapper() = default;
 /// @brief Flush virtual address.
 /// @param VirtAddr
 Void PageMgr::FlushTLB() {
-#ifndef __NE_MINIMAL_OS__
+#ifdef __NE_VIRTUAL_MEMORY_SUPPORT__
   hal_flush_tlb();
-#endif  // !__NE_MINIMAL_OS__
+#endif  // !__NE_VIRTUAL_MEMORY_SUPPORT__
 }
 
 /// @brief Reclaim freed page.