From fb790b07aeba8e22e4190cf3e1834d11ecde6c96 Mon Sep 17 00:00:00 2001
From: Amlal <amlal@nekernel.org>
Date: Fri, 25 Apr 2025 13:08:33 +0200
Subject: dev: better .clang-format, ran format command.

Signed-off-by: Amlal <amlal@nekernel.org>
---
 dev/kernel/src/PEFCodeMgr.cc | 448 ++++++++++++++++++++-----------------------
 1 file changed, 207 insertions(+), 241 deletions(-)

(limited to 'dev/kernel/src/PEFCodeMgr.cc')

diff --git a/dev/kernel/src/PEFCodeMgr.cc b/dev/kernel/src/PEFCodeMgr.cc
index 668dd916..7a75f386 100644
--- a/dev/kernel/src/PEFCodeMgr.cc
+++ b/dev/kernel/src/PEFCodeMgr.cc
@@ -1,6 +1,6 @@
 /* -------------------------------------------
 
-	Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
+  Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
 
 ------------------------------------------- */
 
@@ -9,260 +9,226 @@
 #include <KernelKit/PEFCodeMgr.h>
 #include <KernelKit/ProcessScheduler.h>
 #include <NewKit/Defines.h>
+#include <NewKit/KString.h>
 #include <NewKit/KernelPanic.h>
 #include <NewKit/OwnPtr.h>
-#include <NewKit/KString.h>
 
 /// @brief PEF stack size symbol.
 #define kPefStackSizeSymbol "__PEFSizeOfReserveStack"
-#define kPefHeapSizeSymbol	"__PEFSizeOfReserveHeap"
-#define kPefNameSymbol		"__PEFProgramName"
-
-namespace Kernel
-{
-	namespace Detail
-	{
-		/***********************************************************************************/
-		/// @brief Get the PEF platform signature according to the compiled architecture.
-		/***********************************************************************************/
-		UInt32 ldr_get_platform(void) noexcept
-		{
+#define kPefHeapSizeSymbol "__PEFSizeOfReserveHeap"
+#define kPefNameSymbol "__PEFProgramName"
+
+namespace Kernel {
+namespace Detail {
+  /***********************************************************************************/
+  /// @brief Get the PEF platform signature according to the compiled architecture.
+  /***********************************************************************************/
+  UInt32 ldr_get_platform(void) noexcept {
 #if defined(__NE_32X0__)
-			return kPefArch32x0;
+    return kPefArch32x0;
 #elif defined(__NE_64X0__)
-			return kPefArch64x0;
+    return kPefArch64x0;
 #elif defined(__NE_AMD64__)
-			return kPefArchAMD64;
+    return kPefArchAMD64;
 #elif defined(__NE_PPC64__)
-			return kPefArchPowerPC;
+    return kPefArchPowerPC;
 #elif defined(__NE_ARM64__)
-			return kPefArchARM64;
+    return kPefArchARM64;
 #else
-			return kPefArchInvalid;
-#endif // __32x0__ || __64x0__ || __x86_64__
-		}
-	} // namespace Detail
-
-	/***********************************************************************************/
-	/// @brief PEF loader constructor w/ blob.
-	/// @param blob file blob.
-	/***********************************************************************************/
-	PEFLoader::PEFLoader(const VoidPtr blob)
-		: fCachedBlob(blob)
-	{
-		MUST_PASS(fCachedBlob);
-		fBad = false;
-	}
-
-	/***********************************************************************************/
-	/// @brief PEF loader constructor.
-	/// @param path the filesystem path.
-	/***********************************************************************************/
-	PEFLoader::PEFLoader(const Char* path)
-		: fCachedBlob(nullptr), fFatBinary(false), fBad(false)
-	{
-		fFile.New(const_cast<Char*>(path), kRestrictRB);
-		fPath = KStringBuilder::Construct(path).Leak();
-
-		auto kPefHeader = "PEF_CONTAINER";
-
-		fCachedBlob = fFile->Read(kPefHeader, mib_cast(16));
-
-		PEFContainer* container = reinterpret_cast<PEFContainer*>(fCachedBlob);
-
-		if (container->Cpu == Detail::ldr_get_platform() &&
-			container->Magic[0] == kPefMagic[0] &&
-			container->Magic[1] == kPefMagic[1] &&
-			container->Magic[2] == kPefMagic[2] &&
-			container->Magic[3] == kPefMagic[3] &&
-			container->Magic[4] == kPefMagic[4] && container->Abi == kPefAbi)
-		{
-			return;
-		}
-		else if (container->Magic[4] == kPefMagic[0] &&
-				 container->Magic[3] == kPefMagic[1] &&
-				 container->Magic[2] == kPefMagic[2] &&
-				 container->Magic[1] == kPefMagic[3] &&
-				 container->Magic[0] == kPefMagic[4] && container->Abi == kPefAbi)
-		{
-			/// This is a fat binary.
-			this->fFatBinary = true;
-			return;
-		}
-
-		fBad = true;
-
-		if (fCachedBlob)
-			mm_delete_heap(fCachedBlob);
-
-		kout << "PEFLoader: warn: Executable format error!\r";
-
-		fCachedBlob = nullptr;
-	}
-
-	/***********************************************************************************/
-	/// @brief PEF destructor.
-	/***********************************************************************************/
-	PEFLoader::~PEFLoader()
-	{
-		if (fCachedBlob)
-			mm_delete_heap(fCachedBlob);
-
-		fFile.Delete();
-	}
-
-	/***********************************************************************************/
-	/// @brief Finds the symbol according to it's name.
-	/// @param name name of symbol.
-	/// @param kind kind of symbol we want.
-	/***********************************************************************************/
-	VoidPtr PEFLoader::FindSymbol(const Char* name, Int32 kind)
-	{
-		if (!fCachedBlob || fBad || !name)
-			return nullptr;
-
-		PEFContainer* container = reinterpret_cast<PEFContainer*>(fCachedBlob);
-
-		auto blob = fFile->Read(name, mib_cast(16));
-
-		PEFCommandHeader* container_header = reinterpret_cast<PEFCommandHeader*>(blob);
-
-		constexpr auto cMangleCharacter	 = '$';
-		const Char*	   cContainerKinds[] = {".code64", ".data64", ".zero64", nullptr};
-
-		ErrorOr<KString> error_or_symbol;
-
-		switch (kind)
-		{
-		case kPefCode: {
-			error_or_symbol = KStringBuilder::Construct(cContainerKinds[0]); // code symbol.
-			break;
-		}
-		case kPefData: {
-			error_or_symbol = KStringBuilder::Construct(cContainerKinds[1]); // data symbol.
-			break;
-		}
-		case kPefZero: {
-			error_or_symbol = KStringBuilder::Construct(cContainerKinds[2]); // block starting symbol.
-			break;
-		}
-		default:
-			return nullptr; // prevent that from the kernel's mode perspective, let that happen if it were
-							// a user process.
-		}
-
-		Char* unconst_symbol = const_cast<Char*>(name);
-
-		for (SizeT i = 0UL; i < rt_string_len(unconst_symbol, kPefNameLen); ++i)
-		{
-			if (unconst_symbol[i] == ' ')
-			{
-				unconst_symbol[i] = cMangleCharacter;
-			}
-		}
-
-		error_or_symbol.Leak().Leak() += name;
-
-		for (SizeT index = 0; index < container->Count; ++index)
-		{
-			if (KStringBuilder::Equals(container_header->Name,
-									   error_or_symbol.Leak().Leak().CData()))
-			{
-				if (container_header->Kind == kind)
-				{
-					if (container_header->Cpu != Detail::ldr_get_platform())
-					{
-						if (!this->fFatBinary)
-						{
-							mm_delete_heap(blob);
-							return nullptr;
-						}
-					}
-
-					Char* container_blob_value = new Char[container_header->Size];
-
-					rt_copy_memory((VoidPtr)((Char*)blob + sizeof(PEFCommandHeader)), container_blob_value, container_header->Size);
-					mm_delete_heap(blob);
-
-					kout << "PEFLoader: INFO: Load stub: " << container_header->Name << "!\r";
-
-					return container_blob_value;
-				}
-			}
-		}
-
-		mm_delete_heap(blob);
-		return nullptr;
-	}
-
-	/// @brief Finds the executable entrypoint.
-	/// @return
-	ErrorOr<VoidPtr> PEFLoader::FindStart()
-	{
-		if (auto sym = this->FindSymbol(kPefStart, kPefCode); sym)
-			return ErrorOr<VoidPtr>(sym);
-
-		return ErrorOr<VoidPtr>(kErrorExecutable);
-	}
-
-	/// @brief Tells if the executable is loaded or not.
-	/// @return
-	bool PEFLoader::IsLoaded() noexcept
-	{
-		return !fBad && fCachedBlob;
-	}
-
-	const Char* PEFLoader::Path()
-	{
-		return fPath.Leak().CData();
-	}
-
-	const Char* PEFLoader::AsString()
-	{
+    return kPefArchInvalid;
+#endif  // __32x0__ || __64x0__ || __x86_64__
+  }
+}  // namespace Detail
+
+/***********************************************************************************/
+/// @brief PEF loader constructor w/ blob.
+/// @param blob file blob.
+/***********************************************************************************/
+PEFLoader::PEFLoader(const VoidPtr blob) : fCachedBlob(blob) {
+  MUST_PASS(fCachedBlob);
+  fBad = false;
+}
+
+/***********************************************************************************/
+/// @brief PEF loader constructor.
+/// @param path the filesystem path.
+/***********************************************************************************/
+PEFLoader::PEFLoader(const Char* path) : fCachedBlob(nullptr), fFatBinary(false), fBad(false) {
+  fFile.New(const_cast<Char*>(path), kRestrictRB);
+  fPath = KStringBuilder::Construct(path).Leak();
+
+  auto kPefHeader = "PEF_CONTAINER";
+
+  fCachedBlob = fFile->Read(kPefHeader, mib_cast(16));
+
+  PEFContainer* container = reinterpret_cast<PEFContainer*>(fCachedBlob);
+
+  if (container->Cpu == Detail::ldr_get_platform() && container->Magic[0] == kPefMagic[0] &&
+      container->Magic[1] == kPefMagic[1] && container->Magic[2] == kPefMagic[2] &&
+      container->Magic[3] == kPefMagic[3] && container->Magic[4] == kPefMagic[4] &&
+      container->Abi == kPefAbi) {
+    return;
+  } else if (container->Magic[4] == kPefMagic[0] && container->Magic[3] == kPefMagic[1] &&
+             container->Magic[2] == kPefMagic[2] && container->Magic[1] == kPefMagic[3] &&
+             container->Magic[0] == kPefMagic[4] && container->Abi == kPefAbi) {
+    /// This is a fat binary.
+    this->fFatBinary = true;
+    return;
+  }
+
+  fBad = true;
+
+  if (fCachedBlob) mm_delete_heap(fCachedBlob);
+
+  kout << "PEFLoader: warn: Executable format error!\r";
+
+  fCachedBlob = nullptr;
+}
+
+/***********************************************************************************/
+/// @brief PEF destructor.
+/***********************************************************************************/
+PEFLoader::~PEFLoader() {
+  if (fCachedBlob) mm_delete_heap(fCachedBlob);
+
+  fFile.Delete();
+}
+
+/***********************************************************************************/
+/// @brief Finds the symbol according to it's name.
+/// @param name name of symbol.
+/// @param kind kind of symbol we want.
+/***********************************************************************************/
+VoidPtr PEFLoader::FindSymbol(const Char* name, Int32 kind) {
+  if (!fCachedBlob || fBad || !name) return nullptr;
+
+  PEFContainer* container = reinterpret_cast<PEFContainer*>(fCachedBlob);
+
+  auto blob = fFile->Read(name, mib_cast(16));
+
+  PEFCommandHeader* container_header = reinterpret_cast<PEFCommandHeader*>(blob);
+
+  constexpr auto cMangleCharacter  = '$';
+  const Char*    cContainerKinds[] = {".code64", ".data64", ".zero64", nullptr};
+
+  ErrorOr<KString> error_or_symbol;
+
+  switch (kind) {
+    case kPefCode: {
+      error_or_symbol = KStringBuilder::Construct(cContainerKinds[0]);  // code symbol.
+      break;
+    }
+    case kPefData: {
+      error_or_symbol = KStringBuilder::Construct(cContainerKinds[1]);  // data symbol.
+      break;
+    }
+    case kPefZero: {
+      error_or_symbol = KStringBuilder::Construct(cContainerKinds[2]);  // block starting symbol.
+      break;
+    }
+    default:
+      return nullptr;  // prevent that from the kernel's mode perspective, let that happen if it
+                       // were a user process.
+  }
+
+  Char* unconst_symbol = const_cast<Char*>(name);
+
+  for (SizeT i = 0UL; i < rt_string_len(unconst_symbol, kPefNameLen); ++i) {
+    if (unconst_symbol[i] == ' ') {
+      unconst_symbol[i] = cMangleCharacter;
+    }
+  }
+
+  error_or_symbol.Leak().Leak() += name;
+
+  for (SizeT index = 0; index < container->Count; ++index) {
+    if (KStringBuilder::Equals(container_header->Name, error_or_symbol.Leak().Leak().CData())) {
+      if (container_header->Kind == kind) {
+        if (container_header->Cpu != Detail::ldr_get_platform()) {
+          if (!this->fFatBinary) {
+            mm_delete_heap(blob);
+            return nullptr;
+          }
+        }
+
+        Char* container_blob_value = new Char[container_header->Size];
+
+        rt_copy_memory((VoidPtr) ((Char*) blob + sizeof(PEFCommandHeader)), container_blob_value,
+                       container_header->Size);
+        mm_delete_heap(blob);
+
+        kout << "PEFLoader: INFO: Load stub: " << container_header->Name << "!\r";
+
+        return container_blob_value;
+      }
+    }
+  }
+
+  mm_delete_heap(blob);
+  return nullptr;
+}
+
+/// @brief Finds the executable entrypoint.
+/// @return
+ErrorOr<VoidPtr> PEFLoader::FindStart() {
+  if (auto sym = this->FindSymbol(kPefStart, kPefCode); sym) return ErrorOr<VoidPtr>(sym);
+
+  return ErrorOr<VoidPtr>(kErrorExecutable);
+}
+
+/// @brief Tells if the executable is loaded or not.
+/// @return
+bool PEFLoader::IsLoaded() noexcept {
+  return !fBad && fCachedBlob;
+}
+
+const Char* PEFLoader::Path() {
+  return fPath.Leak().CData();
+}
+
+const Char* PEFLoader::AsString() {
 #ifdef __32x0__
-		return "32x0 PEF executable.";
+  return "32x0 PEF executable.";
 #elif defined(__64x0__)
-		return "64x0 PEF executable.";
+  return "64x0 PEF executable.";
 #elif defined(__x86_64__)
-		return "x86_64 PEF executable.";
+  return "x86_64 PEF executable.";
 #elif defined(__aarch64__)
-		return "AARCH64 PEF executable.";
+  return "AARCH64 PEF executable.";
 #elif defined(__powerpc64__)
-		return "POWER64 PEF executable.";
+  return "POWER64 PEF executable.";
 #else
-		return "???? PEF executable.";
-#endif // __32x0__ || __64x0__ || __x86_64__ || __powerpc64__
-	}
-
-	const Char* PEFLoader::MIME()
-	{
-		return kPefApplicationMime;
-	}
-
-	ErrorOr<VoidPtr> PEFLoader::GetBlob()
-	{
-		return ErrorOr<VoidPtr>{this->fCachedBlob};
-	}
-
-	namespace Utils
-	{
-		ProcessID rtl_create_user_process(PEFLoader& exec, const Int32& process_kind) noexcept
-		{
-			auto errOrStart = exec.FindStart();
-
-			if (errOrStart.Error() != kErrorSuccess)
-				return kSchedInvalidPID;
-
-			auto id = UserProcessScheduler::The().Spawn(reinterpret_cast<const Char*>(exec.FindSymbol(kPefNameSymbol, kPefData)), errOrStart.Leak().Leak(), exec.GetBlob().Leak().Leak());
-
-			if (id != kSchedInvalidPID)
-			{
-				UserProcessScheduler::The().CurrentTeam().AsArray()[id].Kind		= process_kind;
-				UserProcessScheduler::The().CurrentTeam().AsArray()[id].StackSize	= *(UIntPtr*)exec.FindSymbol(kPefStackSizeSymbol, kPefData);
-				UserProcessScheduler::The().CurrentTeam().AsArray()[id].MemoryLimit = *(UIntPtr*)exec.FindSymbol(kPefHeapSizeSymbol, kPefData);
-			}
-
-			return id;
-		}
-	} // namespace Utils
-} // namespace Kernel
+  return "???? PEF executable.";
+#endif  // __32x0__ || __64x0__ || __x86_64__ || __powerpc64__
+}
+
+const Char* PEFLoader::MIME() {
+  return kPefApplicationMime;
+}
+
+ErrorOr<VoidPtr> PEFLoader::GetBlob() {
+  return ErrorOr<VoidPtr>{this->fCachedBlob};
+}
+
+namespace Utils {
+  ProcessID rtl_create_user_process(PEFLoader& exec, const Int32& process_kind) noexcept {
+    auto errOrStart = exec.FindStart();
+
+    if (errOrStart.Error() != kErrorSuccess) return kSchedInvalidPID;
+
+    auto id = UserProcessScheduler::The().Spawn(
+        reinterpret_cast<const Char*>(exec.FindSymbol(kPefNameSymbol, kPefData)),
+        errOrStart.Leak().Leak(), exec.GetBlob().Leak().Leak());
+
+    if (id != kSchedInvalidPID) {
+      UserProcessScheduler::The().CurrentTeam().AsArray()[id].Kind = process_kind;
+      UserProcessScheduler::The().CurrentTeam().AsArray()[id].StackSize =
+          *(UIntPtr*) exec.FindSymbol(kPefStackSizeSymbol, kPefData);
+      UserProcessScheduler::The().CurrentTeam().AsArray()[id].MemoryLimit =
+          *(UIntPtr*) exec.FindSymbol(kPefHeapSizeSymbol, kPefData);
+    }
+
+    return id;
+  }
+}  // namespace Utils
+}  // namespace Kernel
-- 
cgit v1.2.3


From 2ef7b73cff0d99d04e5091e98b3988532e2b1063 Mon Sep 17 00:00:00 2001
From: Amlal <amlal@nekernel.org>
Date: Thu, 1 May 2025 08:50:50 +0200
Subject: kernel: mmap the blob to VMAddress in PEFCodeMgr, alongside other
 fixes regarding memory leaks.

Signed-off-by: Amlal <amlal@nekernel.org>
---
 dev/kernel/HALKit/AMD64/HalPagingMgrAMD64.cc    | 21 ++++---
 dev/kernel/HALKit/AMD64/Processor.h             |  2 +-
 dev/kernel/HALKit/AMD64/Storage/AHCI+Generic.cc |  4 +-
 dev/kernel/HALKit/ARM64/Processor.h             |  2 +-
 dev/kernel/KernelKit/IPEFDylibObject.h          |  2 +-
 dev/kernel/KernelKit/LoaderInterface.h          |  2 +-
 dev/kernel/KernelKit/PECodeMgr.h                |  2 +-
 dev/kernel/KernelKit/PEF.h                      |  2 +-
 dev/kernel/KernelKit/PEFCodeMgr.h               |  2 +-
 dev/kernel/src/PEFCodeMgr.cc                    | 84 ++++++++++++++++---------
 tooling/mkfs.hefs.cc                            |  2 +-
 11 files changed, 76 insertions(+), 49 deletions(-)

(limited to 'dev/kernel/src/PEFCodeMgr.cc')

diff --git a/dev/kernel/HALKit/AMD64/HalPagingMgrAMD64.cc b/dev/kernel/HALKit/AMD64/HalPagingMgrAMD64.cc
index 7a3e776f..4681b5e5 100644
--- a/dev/kernel/HALKit/AMD64/HalPagingMgrAMD64.cc
+++ b/dev/kernel/HALKit/AMD64/HalPagingMgrAMD64.cc
@@ -40,13 +40,14 @@ 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 << (pte->ProtectionKey ? "Protected" : "Not Protected/PKU Disabled") << kendl);
+  (Void)(kout << "Flag: " << (pte->Present ? "Present" : "Not Present") << kendl);
+  (Void)(kout << "Flag: " << (pte->Wr ? "W/R" : "Not W/R") << kendl);
+  (Void)(kout << "Flag: " << (pte->Nx ? "NX" : "Not NX") << kendl);
+  (Void)(kout << "Flag: " << pte->User ? "User" : "Not User") << kendl);
+  (Void)(kout << "Flag: " << (pte->Pcd ? "Not Cached" : "Cached") << kendl);
+  (Void)(kout << "Flag: " << (pte->Accessed ? "Accessed" : "Not Accessed") << kendl);
+  (Void)(kout << "Flag: " << (pte->ProtectionKey ? "Protected" : "Not Protected/PKU Disabled")
+              << kendl);
   (Void)(kout << "Physical Address: " << hex_number(pte->PhysicalAddress) << kendl);
 #endif
 }
@@ -56,7 +57,7 @@ STATIC Void mmi_page_status(Detail::PTE* pte) {
 /// @param virt a valid virtual address.
 /// @return Physical address.
 /***********************************************************************************/
-UIntPtr hal_get_phys_address(VoidPtr virt) {
+UIntPtr mm_get_phys_address(VoidPtr virt) {
   const UInt64 kVMAddr         = (UInt64) virt;
   const UInt64 kMask9Bits      = 0x1FFULL;
   const UInt64 kPageOffsetMask = 0xFFFULL;
@@ -101,7 +102,7 @@ UIntPtr hal_get_phys_address(VoidPtr virt) {
 /// @brief clflush+mfence helper function.
 /***********************************************************************************/
 EXTERN_C Int32 mm_memory_fence(VoidPtr virtual_address) {
-  if (!virtual_address || !hal_get_phys_address(virtual_address)) return kErrorInvalidData;
+  if (!virtual_address || !mm_get_phys_address(virtual_address)) return kErrorInvalidData;
 
   asm volatile("clflush (%0)" : : "r"(virtual_address) : "memory");
   asm volatile("mfence" ::: "memory");
@@ -117,6 +118,8 @@ EXTERN_C Int32 mm_memory_fence(VoidPtr virtual_address) {
 /// @return Status code of page manipulation process.
 /***********************************************************************************/
 EXTERN_C Int32 mm_map_page(VoidPtr virtual_address, VoidPtr physical_address, UInt32 flags) {
+  if (physical_address == 0) return kErrorInvalidData;
+
   const UInt64     kVMAddr   = (UInt64) virtual_address;
   constexpr UInt64 kMask9    = 0x1FF;
   constexpr UInt64 kPageMask = 0xFFF;
diff --git a/dev/kernel/HALKit/AMD64/Processor.h b/dev/kernel/HALKit/AMD64/Processor.h
index d7d594d9..e1ce8718 100644
--- a/dev/kernel/HALKit/AMD64/Processor.h
+++ b/dev/kernel/HALKit/AMD64/Processor.h
@@ -179,7 +179,7 @@ inline Bool hal_has_msr() noexcept {
   return edx & (1 << 5);
 }
 
-UIntPtr hal_get_phys_address(VoidPtr virtual_address);
+UIntPtr mm_get_phys_address(VoidPtr virtual_address);
 
 /***********************************************************************************/
 /// @brief Get Model specific register inside core.
diff --git a/dev/kernel/HALKit/AMD64/Storage/AHCI+Generic.cc b/dev/kernel/HALKit/AMD64/Storage/AHCI+Generic.cc
index d09fd71a..eba2f892 100644
--- a/dev/kernel/HALKit/AMD64/Storage/AHCI+Generic.cc
+++ b/dev/kernel/HALKit/AMD64/Storage/AHCI+Generic.cc
@@ -324,7 +324,7 @@ STATIC Bool drv_init_command_structures_ahci() {
     return NO;
   }
 
-  UIntPtr clb_phys = HAL::hal_get_phys_address(clb_mem);
+  UIntPtr clb_phys = HAL::mm_get_phys_address(clb_mem);
 
   kSATAHba->Ports[kSATAIndex].Clb  = (UInt32) (clb_phys & 0xFFFFFFFF);
   kSATAHba->Ports[kSATAIndex].Clbu = (UInt32) (clb_phys >> 32);
@@ -344,7 +344,7 @@ STATIC Bool drv_init_command_structures_ahci() {
       return NO;
     }
 
-    UIntPtr ct_phys = HAL::hal_get_phys_address(ct_mem);
+    UIntPtr ct_phys = HAL::mm_get_phys_address(ct_mem);
 
     header[i].Ctba  = (UInt32) (ct_phys & 0xFFFFFFFF);
     header[i].Ctbau = (UInt32) (ct_phys >> 32);
diff --git a/dev/kernel/HALKit/ARM64/Processor.h b/dev/kernel/HALKit/ARM64/Processor.h
index 38902627..1d9d2af2 100644
--- a/dev/kernel/HALKit/ARM64/Processor.h
+++ b/dev/kernel/HALKit/ARM64/Processor.h
@@ -36,7 +36,7 @@ enum {
 /// @return Status code of page manip.
 EXTERN_C Int32 mm_map_page(VoidPtr virtual_address, VoidPtr physical_address, UInt32 flags);
 
-EXTERN_C UIntPtr hal_get_phys_address(VoidPtr virtual_address);
+EXTERN_C UIntPtr mm_get_phys_address(VoidPtr virtual_address);
 
 typedef UIntPtr    Reg;
 typedef Register64 Register;
diff --git a/dev/kernel/KernelKit/IPEFDylibObject.h b/dev/kernel/KernelKit/IPEFDylibObject.h
index 4031bd85..42ed1830 100644
--- a/dev/kernel/KernelKit/IPEFDylibObject.h
+++ b/dev/kernel/KernelKit/IPEFDylibObject.h
@@ -62,7 +62,7 @@ class IPEFDylibObject final NE_DYLIB_OBJECT {
     if (symbol_name == nullptr || *symbol_name == 0) return nullptr;
     if (len > kPathLen || len < 1) return nullptr;
 
-    auto ret = reinterpret_cast<SymbolType>(fLoader->FindSymbol(symbol_name, kind));
+    auto ret = reinterpret_cast<SymbolType>(fLoader->FindSymbol(symbol_name, kind).Leak().Leak());
 
     if (!ret) {
       if (kind == kPefCode) return (VoidPtr) &__zka_pure_call;
diff --git a/dev/kernel/KernelKit/LoaderInterface.h b/dev/kernel/KernelKit/LoaderInterface.h
index 42046a53..f6a1b7e9 100644
--- a/dev/kernel/KernelKit/LoaderInterface.h
+++ b/dev/kernel/KernelKit/LoaderInterface.h
@@ -27,6 +27,6 @@ class LoaderInterface {
   virtual _Output const Char*      MIME()                                                 = 0;
   virtual _Output const Char*      Path()                                                 = 0;
   virtual _Output ErrorOr<VoidPtr> FindStart()                                            = 0;
-  virtual _Output VoidPtr          FindSymbol(_Input const Char* name, _Input Int32 kind) = 0;
+  virtual _Output ErrorOr<VoidPtr> FindSymbol(_Input const Char* name, _Input Int32 kind) = 0;
 };
 }  // namespace Kernel
diff --git a/dev/kernel/KernelKit/PECodeMgr.h b/dev/kernel/KernelKit/PECodeMgr.h
index 860f3426..05a2674c 100644
--- a/dev/kernel/KernelKit/PECodeMgr.h
+++ b/dev/kernel/KernelKit/PECodeMgr.h
@@ -55,7 +55,7 @@ class PE32Loader : public LoaderInterface {
 
  public:
   ErrorOr<VoidPtr> FindStart() override;
-  VoidPtr          FindSymbol(const Char* name, Int32 kind) override;
+  ErrorOr<VoidPtr> FindSymbol(const Char* name, Int32 kind) override;
   ErrorOr<VoidPtr> GetBlob() override;
 
  public:
diff --git a/dev/kernel/KernelKit/PEF.h b/dev/kernel/KernelKit/PEF.h
index 03398b48..9381e491 100644
--- a/dev/kernel/KernelKit/PEF.h
+++ b/dev/kernel/KernelKit/PEF.h
@@ -98,7 +98,7 @@ typedef struct PEFCommandHeader final {
   UInt32  Flags;             /* container flags */
   UInt16  Kind;              /* container kind */
   UIntPtr Offset;            /* content offset */
-  UIntPtr  VMAddress;         /* VM offset */
+  UIntPtr VMAddress;         /* VM offset */
   SizeT   Size;              /* content Size */
 } PACKED PEFCommandHeader;
 
diff --git a/dev/kernel/KernelKit/PEFCodeMgr.h b/dev/kernel/KernelKit/PEFCodeMgr.h
index b3ca43d0..a637892f 100644
--- a/dev/kernel/KernelKit/PEFCodeMgr.h
+++ b/dev/kernel/KernelKit/PEFCodeMgr.h
@@ -42,7 +42,7 @@ class PEFLoader : public LoaderInterface {
 
  public:
   ErrorOr<VoidPtr> FindStart() override;
-  VoidPtr          FindSymbol(const Char* name, Int32 kind) override;
+  ErrorOr<VoidPtr> FindSymbol(const Char* name, Int32 kind) override;
   ErrorOr<VoidPtr> GetBlob() override;
 
  public:
diff --git a/dev/kernel/src/PEFCodeMgr.cc b/dev/kernel/src/PEFCodeMgr.cc
index 7a75f386..632d5baa 100644
--- a/dev/kernel/src/PEFCodeMgr.cc
+++ b/dev/kernel/src/PEFCodeMgr.cc
@@ -80,7 +80,7 @@ PEFLoader::PEFLoader(const Char* path) : fCachedBlob(nullptr), fFatBinary(false)
 
   if (fCachedBlob) mm_delete_heap(fCachedBlob);
 
-  kout << "PEFLoader: warn: Executable format error!\r";
+  kout << "PEFLoader: Warning: Executable format error!\r";
 
   fCachedBlob = nullptr;
 }
@@ -99,43 +99,44 @@ PEFLoader::~PEFLoader() {
 /// @param name name of symbol.
 /// @param kind kind of symbol we want.
 /***********************************************************************************/
-VoidPtr PEFLoader::FindSymbol(const Char* name, Int32 kind) {
-  if (!fCachedBlob || fBad || !name) return nullptr;
+ErrorOr<VoidPtr> PEFLoader::FindSymbol(const Char* name, Int32 kind) {
+  if (!fCachedBlob || fBad || !name) return ErrorOr<VoidPtr>{kErrorInvalidData};
 
   PEFContainer* container = reinterpret_cast<PEFContainer*>(fCachedBlob);
 
-  auto blob = fFile->Read(name, mib_cast(16));
+  auto blob = fFile->Read(name, sizeof(PEFCommandHeader));
 
   PEFCommandHeader* container_header = reinterpret_cast<PEFCommandHeader*>(blob);
 
-  constexpr auto cMangleCharacter  = '$';
-  const Char*    cContainerKinds[] = {".code64", ".data64", ".zero64", nullptr};
+  constexpr auto kMangleCharacter  = '$';
+  const Char*    kContainerKinds[] = {".code64", ".data64", ".zero64", nullptr};
 
   ErrorOr<KString> error_or_symbol;
 
   switch (kind) {
     case kPefCode: {
-      error_or_symbol = KStringBuilder::Construct(cContainerKinds[0]);  // code symbol.
+      error_or_symbol = KStringBuilder::Construct(kContainerKinds[0]);  // code symbol.
       break;
     }
     case kPefData: {
-      error_or_symbol = KStringBuilder::Construct(cContainerKinds[1]);  // data symbol.
+      error_or_symbol = KStringBuilder::Construct(kContainerKinds[1]);  // data symbol.
       break;
     }
     case kPefZero: {
-      error_or_symbol = KStringBuilder::Construct(cContainerKinds[2]);  // block starting symbol.
+      error_or_symbol = KStringBuilder::Construct(kContainerKinds[2]);  // block starting symbol.
       break;
     }
     default:
-      return nullptr;  // prevent that from the kernel's mode perspective, let that happen if it
-                       // were a user process.
+      return ErrorOr<VoidPtr>{kErrorInvalidData};
+      ;  // prevent that from the kernel's mode perspective, let that happen if it
+         // were a user process.
   }
 
   Char* unconst_symbol = const_cast<Char*>(name);
 
   for (SizeT i = 0UL; i < rt_string_len(unconst_symbol, kPefNameLen); ++i) {
     if (unconst_symbol[i] == ' ') {
-      unconst_symbol[i] = cMangleCharacter;
+      unconst_symbol[i] = kMangleCharacter;
     }
   }
 
@@ -147,7 +148,7 @@ VoidPtr PEFLoader::FindSymbol(const Char* name, Int32 kind) {
         if (container_header->Cpu != Detail::ldr_get_platform()) {
           if (!this->fFatBinary) {
             mm_delete_heap(blob);
-            return nullptr;
+            return ErrorOr<VoidPtr>{kErrorInvalidData};
           }
         }
 
@@ -157,27 +158,36 @@ VoidPtr PEFLoader::FindSymbol(const Char* name, Int32 kind) {
                        container_header->Size);
         mm_delete_heap(blob);
 
-        kout << "PEFLoader: INFO: Load stub: " << container_header->Name << "!\r";
+        kout << "PEFLoader: Information: Loaded stub: " << container_header->Name << "!\r";
 
-        return container_blob_value;
+        auto ret = HAL::mm_map_page((VoidPtr) container_header->VMAddress,
+                                    (VoidPtr) HAL::mm_get_phys_address(container_blob_value),
+                                    HAL::kMMFlagsPresent | HAL::kMMFlagsUser);
+
+        if (ret != kErrorSuccess) {
+          mm_delete_heap(container_blob_value);
+          return ErrorOr<VoidPtr>{kErrorInvalidData};
+        }
+
+        return ErrorOr<VoidPtr>{container_blob_value};
       }
     }
   }
 
   mm_delete_heap(blob);
-  return nullptr;
+  return ErrorOr<VoidPtr>{kErrorInvalidData};
 }
 
 /// @brief Finds the executable entrypoint.
 /// @return
 ErrorOr<VoidPtr> PEFLoader::FindStart() {
-  if (auto sym = this->FindSymbol(kPefStart, kPefCode); sym) return ErrorOr<VoidPtr>(sym);
+  if (auto sym = this->FindSymbol(kPefStart, kPefCode); sym) return sym;
 
   return ErrorOr<VoidPtr>(kErrorExecutable);
 }
 
 /// @brief Tells if the executable is loaded or not.
-/// @return
+/// @return Whether it's not bad and is cached.
 bool PEFLoader::IsLoaded() noexcept {
   return !fBad && fCachedBlob;
 }
@@ -188,17 +198,17 @@ const Char* PEFLoader::Path() {
 
 const Char* PEFLoader::AsString() {
 #ifdef __32x0__
-  return "32x0 PEF executable.";
+  return "32x0 PEF.";
 #elif defined(__64x0__)
-  return "64x0 PEF executable.";
+  return "64x0 PEF.";
 #elif defined(__x86_64__)
-  return "x86_64 PEF executable.";
+  return "x86_64 PEF.";
 #elif defined(__aarch64__)
-  return "AARCH64 PEF executable.";
+  return "AARCH64 PEF.";
 #elif defined(__powerpc64__)
-  return "POWER64 PEF executable.";
+  return "POWER64 PEF.";
 #else
-  return "???? PEF executable.";
+  return "???? PEF.";
 #endif  // __32x0__ || __64x0__ || __x86_64__ || __powerpc64__
 }
 
@@ -216,16 +226,30 @@ namespace Utils {
 
     if (errOrStart.Error() != kErrorSuccess) return kSchedInvalidPID;
 
-    auto id = UserProcessScheduler::The().Spawn(
-        reinterpret_cast<const Char*>(exec.FindSymbol(kPefNameSymbol, kPefData)),
-        errOrStart.Leak().Leak(), exec.GetBlob().Leak().Leak());
+    auto symname = exec.FindSymbol(kPefNameSymbol, kPefData);
+
+    if (!symname) {
+      symname = ErrorOr<VoidPtr>{(VoidPtr) rt_alloc_string("USER_PROCESS")};
+    }
+
+    auto id =
+        UserProcessScheduler::The().Spawn(reinterpret_cast<const Char*>(symname.Leak().Leak()),
+                                          errOrStart.Leak().Leak(), exec.GetBlob().Leak().Leak());
+
+    mm_delete_heap(symname.Leak().Leak());
 
     if (id != kSchedInvalidPID) {
+      auto stacksym = exec.FindSymbol(kPefStackSizeSymbol, kPefData);
+
+      if (!symname) {
+        stacksym = ErrorOr<VoidPtr>{(VoidPtr) new UIntPtr(mib_cast(16))};
+      }
+
       UserProcessScheduler::The().CurrentTeam().AsArray()[id].Kind = process_kind;
       UserProcessScheduler::The().CurrentTeam().AsArray()[id].StackSize =
-          *(UIntPtr*) exec.FindSymbol(kPefStackSizeSymbol, kPefData);
-      UserProcessScheduler::The().CurrentTeam().AsArray()[id].MemoryLimit =
-          *(UIntPtr*) exec.FindSymbol(kPefHeapSizeSymbol, kPefData);
+          *(UIntPtr*) stacksym.Leak().Leak();
+
+      mm_delete_heap(stacksym.Leak().Leak());
     }
 
     return id;
diff --git a/tooling/mkfs.hefs.cc b/tooling/mkfs.hefs.cc
index 4d7225fe..f19f1571 100644
--- a/tooling/mkfs.hefs.cc
+++ b/tooling/mkfs.hefs.cc
@@ -96,7 +96,7 @@ int main(int argc, char** argv) {
   bootNode.sectorSize = kSectorSize;
   bootNode.startIND   = start_ind;
   bootNode.endIND     = end_ind;
-  bootNode.indCount = 0UL;
+  bootNode.indCount   = 0UL;
   bootNode.diskStatus = mkfs::hefs::kHeFSStatusUnlocked;
 
   std::memcpy(bootNode.magic, kHeFSMagic, kHeFSMagicLen - 1);
-- 
cgit v1.2.3


From dc6c85c9344732a12f5e8f74e4cfc374b8bd391f Mon Sep 17 00:00:00 2001
From: Amlal <amlal@nekernel.org>
Date: Thu, 1 May 2025 12:07:58 +0200
Subject: kernel: scheduler and pef code mgr improvements.

Signed-off-by: Amlal <amlal@nekernel.org>
---
 dev/kernel/HALKit/AMD64/HalKernelMain.cc |  2 ++
 dev/kernel/src/PEFCodeMgr.cc             |  7 ++++++-
 dev/kernel/src/UserProcessScheduler.cc   | 18 ++++++++++++++----
 3 files changed, 22 insertions(+), 5 deletions(-)

(limited to 'dev/kernel/src/PEFCodeMgr.cc')

diff --git a/dev/kernel/HALKit/AMD64/HalKernelMain.cc b/dev/kernel/HALKit/AMD64/HalKernelMain.cc
index 29244add..5de1b8e4 100644
--- a/dev/kernel/HALKit/AMD64/HalKernelMain.cc
+++ b/dev/kernel/HALKit/AMD64/HalKernelMain.cc
@@ -144,6 +144,8 @@ EXTERN_C Kernel::Void hal_real_init(Kernel::Void) noexcept {
       team_index = 0U;
     }
 
+    kTeams[team_index].Id() = team_index;
+
     while (!UserProcessScheduler::The().SwitchTeam(kTeams[team_index]));
 
     timer.Wait();
diff --git a/dev/kernel/src/PEFCodeMgr.cc b/dev/kernel/src/PEFCodeMgr.cc
index 632d5baa..40a0cff9 100644
--- a/dev/kernel/src/PEFCodeMgr.cc
+++ b/dev/kernel/src/PEFCodeMgr.cc
@@ -12,6 +12,7 @@
 #include <NewKit/KString.h>
 #include <NewKit/KernelPanic.h>
 #include <NewKit/OwnPtr.h>
+#include "KernelKit/UserProcessScheduler.h"
 
 /// @brief PEF stack size symbol.
 #define kPefStackSizeSymbol "__PEFSizeOfReserveStack"
@@ -242,7 +243,11 @@ namespace Utils {
       auto stacksym = exec.FindSymbol(kPefStackSizeSymbol, kPefData);
 
       if (!symname) {
-        stacksym = ErrorOr<VoidPtr>{(VoidPtr) new UIntPtr(mib_cast(16))};
+        stacksym = ErrorOr<VoidPtr>{(VoidPtr) new UIntPtr(kSchedMaxStackSz)};
+      }
+
+      if ((*(volatile UIntPtr*)stacksym.Leak().Leak()) > kSchedMaxStackSz) {
+        *(volatile UIntPtr*)stacksym.Leak().Leak() = kSchedMaxStackSz;
       }
 
       UserProcessScheduler::The().CurrentTeam().AsArray()[id].Kind = process_kind;
diff --git a/dev/kernel/src/UserProcessScheduler.cc b/dev/kernel/src/UserProcessScheduler.cc
index 23ab22fa..5012e8a3 100644
--- a/dev/kernel/src/UserProcessScheduler.cc
+++ b/dev/kernel/src/UserProcessScheduler.cc
@@ -486,20 +486,30 @@ Bool UserProcessScheduler::HasMP() {
 /***********************************************************************************/
 
 SizeT UserProcessScheduler::Run() noexcept {
-  SizeT process_index = 0UL;  //! we store this guy to tell the scheduler how many
-                              //! things we have scheduled.
-
   if (mTeam.mProcessCount < 1) {
     return 0UL;
   }
 
+  if (kCurrentlySwitching)
+    return 0UL;
+
   kCurrentlySwitching = Yes;
 
+  SizeT process_index = 0UL;  //! we store this guy to tell the scheduler how many
+                              //! things we have scheduled.
+
   for (; process_index < mTeam.AsArray().Capacity(); ++process_index) {
     auto& process = mTeam.AsArray()[process_index];
 
-    //! check if the process needs to be run.
+    //! Check if the process needs to be run.
     if (UserProcessHelper::CanBeScheduled(process)) {
+
+      if (process.StackSize > kSchedMaxStackSz) {
+        kout << "The process: " << process.Name << ", has not a valid stack size! Crashing it...\r";
+        process.Crash();
+        continue;
+      }
+
       // Set current process header.
       this->CurrentProcess() = process;
 
-- 
cgit v1.2.3


From 7b59d3e2fab595c920771368d33f7a42745cd5b1 Mon Sep 17 00:00:00 2001
From: Amlal <amlal@nekernel.org>
Date: Thu, 1 May 2025 16:44:37 +0200
Subject: kernel: HeFS: did progress on IND allocation.

Signed-off-by: Amlal <amlal@nekernel.org>
---
 dev/kernel/src/FS/HeFS.cc              |  82 ++--
 dev/kernel/src/PEFCodeMgr.cc           |   4 +-
 dev/kernel/src/UserProcessScheduler.cc |   4 +-
 tooling/mkfs.h                         |   8 +-
 tooling/mkfs.hefs.cc                   |  17 +-
 tooling/rang.h                         | 711 ++++++++++++++++-----------------
 6 files changed, 411 insertions(+), 415 deletions(-)

(limited to 'dev/kernel/src/PEFCodeMgr.cc')

diff --git a/dev/kernel/src/FS/HeFS.cc b/dev/kernel/src/FS/HeFS.cc
index 89415ee5..0969d2a5 100644
--- a/dev/kernel/src/FS/HeFS.cc
+++ b/dev/kernel/src/FS/HeFS.cc
@@ -29,7 +29,8 @@ namespace Detail {
   /// @note This function is used to traverse the RB-Tree of the filesystem.
   /// @internal Internal filesystem use only.
   STATIC ATTRIBUTE(unused) _Output Void
-      hefsi_traverse_tree(HEFS_INDEX_NODE_DIRECTORY* dir, Lba& start);
+      hefsi_traverse_tree(HEFS_INDEX_NODE_DIRECTORY* dir, DriveTrait* mnt, const Lba& start_ind,
+                          Lba& start, const BOOL alloc_in_mind = NO);
 
   /// @brief Get the index node of a file or directory.
   /// @param root The root node of the filesystem.
@@ -74,19 +75,52 @@ 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) _Output Void
-      hefsi_traverse_tree(HEFS_INDEX_NODE_DIRECTORY* dir, Lba& start) {
-    if (dir->fNext != 0) {
-      start = dir->fNext;
-    } else if (dir->fPrev != 0) {
-      start = dir->fPrev;
-    } else {
-      if (dir->fParent != 0) {
-        start = dir->fParent;
+  STATIC ATTRIBUTE(unused) Void
+      hefsi_traverse_tree(HEFS_INDEX_NODE_DIRECTORY* dir, DriveTrait* mnt, const Lba& ind_start,
+                          Lba& start, const BOOL alloc_in_mind) {
+    if (!mnt || !dir) return;
+
+    BOOL check_is_good = NO;
+
+    while (YES) {
+      mnt->fPacket.fPacketLba     = start;
+      mnt->fPacket.fPacketSize    = sizeof(HEFS_INDEX_NODE_DIRECTORY);
+      mnt->fPacket.fPacketContent = dir;
+      mnt->fInput(mnt->fPacket);
+
+      if (dir->fNext != 0) {
+        if (check_is_good) break;
+
+        start = dir->fNext;
+
+        check_is_good = YES;
+        continue;
       } else if (dir->fPrev != 0) {
-        start = dir->fPrev;
+        if (check_is_good) break;
+
+        start         = dir->fPrev;
+        check_is_good = YES;
+        continue;
       } else {
-        start += kHeFSINDStartOffset;
+        if (dir->fParent != 0) {
+          if (check_is_good) break;
+
+          start         = dir->fParent;
+          check_is_good = YES;
+          continue;
+        } else if (dir->fPrev != 0) {
+          if (check_is_good) break;
+
+          start         = dir->fPrev;
+          check_is_good = YES;
+          continue;
+        } else {
+          if (!alloc_in_mind) break;
+
+          if (start < 1) start = ind_start;
+
+          start += kHeFSINDStartOffset;
+        }
       }
     }
 
@@ -320,13 +354,13 @@ namespace Detail {
               }
 
               child += sizeof(HEFS_INDEX_NODE_DIRECTORY);
-              if (child < root->fStartIND || child > root->fEndIND) break;
+              if (child > root->fEndIND) break;
             }
 
             dirent->fColor = kHeFSRed;
             dirent->fChild = child;
 
-            if (child > root->fEndIND) dirent->fChild = root->fEndIND;
+            if (child > root->fEndIND) dirent->fChild = root->fStartIND;
           }
 
           for (SizeT index = 0UL; index < (kHeFSSliceCount * 2); index += 2) {
@@ -358,7 +392,7 @@ namespace Detail {
           return YES;
         }
 
-        hefsi_traverse_tree(tmpdir, start);
+        hefsi_traverse_tree(tmpdir, mnt, root->fStartIND, start, YES);
         if (start > root->fEndIND || start == 0) break;
       }
 
@@ -404,7 +438,7 @@ namespace Detail {
           }
         }
 
-        hefsi_traverse_tree(dir, start);
+        hefsi_traverse_tree(dir, mnt, root->fStartIND, start);
         if (start > root->fEndIND || start == 0) break;
       }
     }
@@ -493,7 +527,7 @@ namespace Detail {
           }
         }
 
-        hefsi_traverse_tree(dir, start);
+        hefsi_traverse_tree(dir, mnt, root->fStartIND, start);
         if (start > root->fEndIND || start == 0) break;
       }
     }
@@ -544,7 +578,7 @@ namespace Detail {
           }
         }
 
-        hefsi_traverse_tree(dir, start);
+        hefsi_traverse_tree(dir, mnt, root->fStartIND, start);
         if (start > root->fEndIND || start == 0) break;
       }
 
@@ -632,7 +666,7 @@ namespace Detail {
 
         if (dir_parent->fNext == start) {
           hefsi_rotate_tree(start, mnt, YES);
-          hefsi_traverse_tree(dir_parent, start);
+          hefsi_traverse_tree(dir_parent, mnt, root->fStartIND, start);
 
           if (start > root->fEndIND || start == 0) break;
 
@@ -658,7 +692,7 @@ namespace Detail {
 
         hefsi_rotate_tree(start, mnt, NO);
 
-        hefsi_traverse_tree(dir, start);
+        hefsi_traverse_tree(dir, mnt, root->fStartIND, start);
         if (start > root->fEndIND || start == 0) break;
       }
 
@@ -750,7 +784,7 @@ _Output Bool HeFileSystemParser::Format(_Input _Output DriveTrait* drive, _Input
   const SizeT dir_max   = max_lba / 20;  // 20% for directory metadata
   const SizeT inode_max = max_lba / 10;  // 10% for inodes
 
-  root->fStartIND = drive->fLbaStart + kHeFSINDStartOffset;
+  root->fStartIND = drive->fLbaStart + kHeFSINDStartOffset + sizeof(HEFS_BOOT_NODE);
   root->fEndIND   = root->fStartIND + dir_max;
 
   root->fStartIN = root->fEndIND + kHeFSINDStartOffset;
@@ -799,7 +833,7 @@ _Output Bool HeFileSystemParser::Format(_Input _Output DriveTrait* drive, _Input
     return NO;
   }
 
-  const Utf8Char* kFileMap[kHeFSPreallocateCount] = {
+  const Utf8Char kFileMap[kHeFSPreallocateCount][kHeFSFileNameLen] = {
       u8"/", u8"/boot", u8"/system", u8"/network", u8"/devices", u8"/media", u8"/vm",
   };
 
@@ -847,7 +881,9 @@ _Output Bool HeFileSystemParser::CreateDirectory(_Input DriveTrait* drive, _Inpu
   urt_copy_memory((VoidPtr) dir, name, urt_string_len(dir) + 1);
 
   if (Detail::hefsi_allocate_index_node_directory(root, drive, name, flags)) {
-    Detail::hefsi_balance_filesystem(root, drive);
+    // todo: make it smarter for high-throughput.
+    if (root->fINDCount > 1024) Detail::hefsi_balance_filesystem(root, drive);
+
     mm_delete_heap((VoidPtr) root);
     delete[] name;
     return YES;
diff --git a/dev/kernel/src/PEFCodeMgr.cc b/dev/kernel/src/PEFCodeMgr.cc
index 40a0cff9..5da3a499 100644
--- a/dev/kernel/src/PEFCodeMgr.cc
+++ b/dev/kernel/src/PEFCodeMgr.cc
@@ -246,8 +246,8 @@ namespace Utils {
         stacksym = ErrorOr<VoidPtr>{(VoidPtr) new UIntPtr(kSchedMaxStackSz)};
       }
 
-      if ((*(volatile UIntPtr*)stacksym.Leak().Leak()) > kSchedMaxStackSz) {
-        *(volatile UIntPtr*)stacksym.Leak().Leak() = kSchedMaxStackSz;
+      if ((*(volatile UIntPtr*) stacksym.Leak().Leak()) > kSchedMaxStackSz) {
+        *(volatile UIntPtr*) stacksym.Leak().Leak() = kSchedMaxStackSz;
       }
 
       UserProcessScheduler::The().CurrentTeam().AsArray()[id].Kind = process_kind;
diff --git a/dev/kernel/src/UserProcessScheduler.cc b/dev/kernel/src/UserProcessScheduler.cc
index 5012e8a3..45a95b5b 100644
--- a/dev/kernel/src/UserProcessScheduler.cc
+++ b/dev/kernel/src/UserProcessScheduler.cc
@@ -490,8 +490,7 @@ SizeT UserProcessScheduler::Run() noexcept {
     return 0UL;
   }
 
-  if (kCurrentlySwitching)
-    return 0UL;
+  if (kCurrentlySwitching) return 0UL;
 
   kCurrentlySwitching = Yes;
 
@@ -503,7 +502,6 @@ SizeT UserProcessScheduler::Run() noexcept {
 
     //! Check if the process needs to be run.
     if (UserProcessHelper::CanBeScheduled(process)) {
-
       if (process.StackSize > kSchedMaxStackSz) {
         kout << "The process: " << process.Name << ", has not a valid stack size! Crashing it...\r";
         process.Crash();
diff --git a/tooling/mkfs.h b/tooling/mkfs.h
index 650261db..7180b179 100644
--- a/tooling/mkfs.h
+++ b/tooling/mkfs.h
@@ -6,9 +6,9 @@
 
 #pragma once
 
+#include <tooling/rang.h>
 #include <iostream>
 #include <string>
-#include <tooling/rang.h>
 
 /// @internal
 namespace mkfs {
@@ -28,9 +28,9 @@ inline std::basic_string<CharType> get_option(const std::basic_string<CharType>&
 }
 
 inline auto console_out() -> std::ostream& {
-    std::ostream& conout = std::cout;
-    conout << rang::fg::red << "mkfs: " << rang::style::reset;
+  std::ostream& conout = std::cout;
+  conout << rang::fg::red << "mkfs: " << rang::style::reset;
 
-    return conout;
+  return conout;
 }
 }  // namespace mkfs
\ No newline at end of file
diff --git a/tooling/mkfs.hefs.cc b/tooling/mkfs.hefs.cc
index d9928858..23772023 100644
--- a/tooling/mkfs.hefs.cc
+++ b/tooling/mkfs.hefs.cc
@@ -16,10 +16,8 @@ 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> -p <part_start> -e "
+                        << "<part_end> -S <disk_size> -o <output_device>" << std::endl;
 
     return EXIT_FAILURE;
   }
@@ -51,8 +49,8 @@ int main(int argc, char** argv) {
       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;
+    mkfs::console_out() << "hefs: Error: Unable to deduce future disk size for output_device: "
+                        << output_device << std::endl;
     return EXIT_FAILURE;
   }
 
@@ -61,7 +59,7 @@ int main(int argc, char** argv) {
 
   if (!filesystem.good()) {
     mkfs::console_out() << "hefs: Info: Unable to open output_device: " << output_device
-    << std::endl;
+                        << std::endl;
     return EXIT_FAILURE;
   }
 
@@ -92,7 +90,7 @@ int main(int argc, char** argv) {
 
   if (!filesystem.good()) {
     mkfs::console_out() << "hefs: Error: Unable to write FS to output_device: " << output_device
-                      << std::endl;
+                        << std::endl;
     return EXIT_FAILURE;
   }
 
@@ -101,8 +99,7 @@ int main(int argc, char** argv) {
   filesystem.flush();
   filesystem.close();
 
-  mkfs::console_out() << "hefs: Info: Wrote FS to output_device: " << output_device
-  << std::endl;
+  mkfs::console_out() << "hefs: Info: Wrote FS to output_device: " << output_device << std::endl;
 
   return EXIT_SUCCESS;
 }
\ No newline at end of file
diff --git a/tooling/rang.h b/tooling/rang.h
index 204ab1dc..5d1c68ef 100644
--- a/tooling/rang.h
+++ b/tooling/rang.h
@@ -17,14 +17,14 @@
 #elif defined(OS_WIN)
 
 #if defined(_WIN32_WINNT) && (_WIN32_WINNT < 0x0600)
-#error                                                                         \
-  "Please include rang.hpp before any windows system headers or set _WIN32_WINNT at least to _WIN32_WINNT_VISTA"
+#error \
+    "Please include rang.hpp before any windows system headers or set _WIN32_WINNT at least to _WIN32_WINNT_VISTA"
 #elif !defined(_WIN32_WINNT)
 #define _WIN32_WINNT _WIN32_WINNT_VISTA
 #endif
 
-#include <windows.h>
 #include <io.h>
+#include <windows.h>
 #include <memory>
 
 // Only defined in windows 10 onwards, redefining in lower windows since it
@@ -49,448 +49,413 @@ namespace rang {
  * Note that on Windows terminals bold style is same as fgB color.
  */
 enum class style {
-    reset     = 0,
-    bold      = 1,
-    dim       = 2,
-    italic    = 3,
-    underline = 4,
-    blink     = 5,
-    rblink    = 6,
-    reversed  = 7,
-    conceal   = 8,
-    crossed   = 9
+  reset     = 0,
+  bold      = 1,
+  dim       = 2,
+  italic    = 3,
+  underline = 4,
+  blink     = 5,
+  rblink    = 6,
+  reversed  = 7,
+  conceal   = 8,
+  crossed   = 9
 };
 
 enum class fg {
-    black   = 30,
-    red     = 31,
-    green   = 32,
-    yellow  = 33,
-    blue    = 34,
-    magenta = 35,
-    cyan    = 36,
-    gray    = 37,
-    reset   = 39
+  black   = 30,
+  red     = 31,
+  green   = 32,
+  yellow  = 33,
+  blue    = 34,
+  magenta = 35,
+  cyan    = 36,
+  gray    = 37,
+  reset   = 39
 };
 
 enum class bg {
-    black   = 40,
-    red     = 41,
-    green   = 42,
-    yellow  = 43,
-    blue    = 44,
-    magenta = 45,
-    cyan    = 46,
-    gray    = 47,
-    reset   = 49
+  black   = 40,
+  red     = 41,
+  green   = 42,
+  yellow  = 43,
+  blue    = 44,
+  magenta = 45,
+  cyan    = 46,
+  gray    = 47,
+  reset   = 49
 };
 
 enum class fgB {
-    black   = 90,
-    red     = 91,
-    green   = 92,
-    yellow  = 93,
-    blue    = 94,
-    magenta = 95,
-    cyan    = 96,
-    gray    = 97
+  black   = 90,
+  red     = 91,
+  green   = 92,
+  yellow  = 93,
+  blue    = 94,
+  magenta = 95,
+  cyan    = 96,
+  gray    = 97
 };
 
 enum class bgB {
-    black   = 100,
-    red     = 101,
-    green   = 102,
-    yellow  = 103,
-    blue    = 104,
-    magenta = 105,
-    cyan    = 106,
-    gray    = 107
+  black   = 100,
+  red     = 101,
+  green   = 102,
+  yellow  = 103,
+  blue    = 104,
+  magenta = 105,
+  cyan    = 106,
+  gray    = 107
 };
 
 enum class control {  // Behaviour of rang function calls
-    Off   = 0,  // toggle off rang style/color calls
-    Auto  = 1,  // (Default) autodect terminal and colorize if needed
-    Force = 2  // force ansi color output to non terminal streams
+  Off   = 0,          // toggle off rang style/color calls
+  Auto  = 1,          // (Default) autodect terminal and colorize if needed
+  Force = 2           // force ansi color output to non terminal streams
 };
 // Use rang::setControlMode to set rang control mode
 
 enum class winTerm {  // Windows Terminal Mode
-    Auto   = 0,  // (Default) automatically detects wheter Ansi or Native API
-    Ansi   = 1,  // Force use Ansi API
-    Native = 2  // Force use Native API
+  Auto   = 0,         // (Default) automatically detects wheter Ansi or Native API
+  Ansi   = 1,         // Force use Ansi API
+  Native = 2          // Force use Native API
 };
 // Use rang::setWinTermMode to explicitly set terminal API for Windows
 // Calling rang::setWinTermMode have no effect on other OS
 
 namespace rang_implementation {
 
-    inline std::atomic<control> &controlMode() noexcept
-    {
-        static std::atomic<control> value(control::Auto);
-        return value;
-    }
+  inline std::atomic<control>& controlMode() noexcept {
+    static std::atomic<control> value(control::Auto);
+    return value;
+  }
 
-    inline std::atomic<winTerm> &winTermMode() noexcept
-    {
-        static std::atomic<winTerm> termMode(winTerm::Auto);
-        return termMode;
-    }
+  inline std::atomic<winTerm>& winTermMode() noexcept {
+    static std::atomic<winTerm> termMode(winTerm::Auto);
+    return termMode;
+  }
 
-    inline bool supportsColor() noexcept
-    {
+  inline bool supportsColor() noexcept {
 #if defined(OS_LINUX) || defined(OS_MAC)
 
-        static const bool result = [] {
-            const char *Terms[]
-              = { "ansi",    "color",  "console", "cygwin", "gnome",
-                  "konsole", "kterm",  "linux",   "msys",   "putty",
-                  "rxvt",    "screen", "vt100",   "xterm" };
-
-            const char *env_p = std::getenv("TERM");
-            if (env_p == nullptr) {
-                return false;
-            }
-            return std::any_of(std::begin(Terms), std::end(Terms),
-                               [&](const char *term) {
-                                   return std::strstr(env_p, term) != nullptr;
-                               });
-        }();
+    static const bool result = [] {
+      const char* Terms[] = {"ansi",  "color", "console", "cygwin", "gnome",  "konsole", "kterm",
+                             "linux", "msys",  "putty",   "rxvt",   "screen", "vt100",   "xterm"};
+
+      const char* env_p = std::getenv("TERM");
+      if (env_p == nullptr) {
+        return false;
+      }
+      return std::any_of(std::begin(Terms), std::end(Terms),
+                         [&](const char* term) { return std::strstr(env_p, term) != nullptr; });
+    }();
 
 #elif defined(OS_WIN)
-        // All windows versions support colors through native console methods
-        static constexpr bool result = true;
+    // All windows versions support colors through native console methods
+    static constexpr bool result = true;
 #endif
-        return result;
-    }
+    return result;
+  }
 
 #ifdef OS_WIN
 
-
-    inline bool isMsysPty(int fd) noexcept
-    {
-        // Dynamic load for binary compability with old Windows
-        const auto ptrGetFileInformationByHandleEx
-          = reinterpret_cast<decltype(&GetFileInformationByHandleEx)>(
-            GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")),
-                           "GetFileInformationByHandleEx"));
-        if (!ptrGetFileInformationByHandleEx) {
-            return false;
-        }
-
-        HANDLE h = reinterpret_cast<HANDLE>(_get_osfhandle(fd));
-        if (h == INVALID_HANDLE_VALUE) {
-            return false;
-        }
-
-        // Check that it's a pipe:
-        if (GetFileType(h) != FILE_TYPE_PIPE) {
-            return false;
-        }
-
-        // POD type is binary compatible with FILE_NAME_INFO from WinBase.h
-        // It have the same alignment and used to avoid UB in caller code
-        struct MY_FILE_NAME_INFO {
-            DWORD FileNameLength;
-            WCHAR FileName[MAX_PATH];
-        };
-
-        auto pNameInfo = std::unique_ptr<MY_FILE_NAME_INFO>(
-          new (std::nothrow) MY_FILE_NAME_INFO());
-        if (!pNameInfo) {
-            return false;
-        }
-
-        // Check pipe name is template of
-        // {"cygwin-","msys-"}XXXXXXXXXXXXXXX-ptyX-XX
-        if (!ptrGetFileInformationByHandleEx(h, FileNameInfo, pNameInfo.get(),
-                                             sizeof(MY_FILE_NAME_INFO))) {
-            return false;
-        }
-        std::wstring name(pNameInfo->FileName, pNameInfo->FileNameLength / sizeof(WCHAR));
-        if ((name.find(L"msys-") == std::wstring::npos
-             && name.find(L"cygwin-") == std::wstring::npos)
-            || name.find(L"-pty") == std::wstring::npos) {
-            return false;
-        }
-
-        return true;
+  inline bool isMsysPty(int fd) noexcept {
+    // Dynamic load for binary compability with old Windows
+    const auto ptrGetFileInformationByHandleEx =
+        reinterpret_cast<decltype(&GetFileInformationByHandleEx)>(
+            GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")), "GetFileInformationByHandleEx"));
+    if (!ptrGetFileInformationByHandleEx) {
+      return false;
     }
 
-#endif
+    HANDLE h = reinterpret_cast<HANDLE>(_get_osfhandle(fd));
+    if (h == INVALID_HANDLE_VALUE) {
+      return false;
+    }
 
-    inline bool isTerminal(const std::streambuf *osbuf) noexcept
-    {
-        using std::cerr;
-        using std::clog;
-        using std::cout;
-#if defined(OS_LINUX) || defined(OS_MAC)
-        if (osbuf == cout.rdbuf()) {
-            static const bool cout_term = isatty(fileno(stdout)) != 0;
-            return cout_term;
-        } else if (osbuf == cerr.rdbuf() || osbuf == clog.rdbuf()) {
-            static const bool cerr_term = isatty(fileno(stderr)) != 0;
-            return cerr_term;
-        }
-#elif defined(OS_WIN)
-        if (osbuf == cout.rdbuf()) {
-            static const bool cout_term
-              = (_isatty(_fileno(stdout)) || isMsysPty(_fileno(stdout)));
-            return cout_term;
-        } else if (osbuf == cerr.rdbuf() || osbuf == clog.rdbuf()) {
-            static const bool cerr_term
-              = (_isatty(_fileno(stderr)) || isMsysPty(_fileno(stderr)));
-            return cerr_term;
-        }
-#endif
-        return false;
+    // Check that it's a pipe:
+    if (GetFileType(h) != FILE_TYPE_PIPE) {
+      return false;
     }
 
-    template <typename T>
-    using enableStd = typename std::enable_if<
-      std::is_same<T, rang::style>::value || std::is_same<T, rang::fg>::value
-        || std::is_same<T, rang::bg>::value || std::is_same<T, rang::fgB>::value
-        || std::is_same<T, rang::bgB>::value,
-      std::ostream &>::type;
+    // POD type is binary compatible with FILE_NAME_INFO from WinBase.h
+    // It have the same alignment and used to avoid UB in caller code
+    struct MY_FILE_NAME_INFO {
+      DWORD FileNameLength;
+      WCHAR FileName[MAX_PATH];
+    };
 
+    auto pNameInfo = std::unique_ptr<MY_FILE_NAME_INFO>(new (std::nothrow) MY_FILE_NAME_INFO());
+    if (!pNameInfo) {
+      return false;
+    }
 
-#ifdef OS_WIN
+    // Check pipe name is template of
+    // {"cygwin-","msys-"}XXXXXXXXXXXXXXX-ptyX-XX
+    if (!ptrGetFileInformationByHandleEx(h, FileNameInfo, pNameInfo.get(),
+                                         sizeof(MY_FILE_NAME_INFO))) {
+      return false;
+    }
+    std::wstring name(pNameInfo->FileName, pNameInfo->FileNameLength / sizeof(WCHAR));
+    if ((name.find(L"msys-") == std::wstring::npos &&
+         name.find(L"cygwin-") == std::wstring::npos) ||
+        name.find(L"-pty") == std::wstring::npos) {
+      return false;
+    }
 
-    struct SGR {  // Select Graphic Rendition parameters for Windows console
-        BYTE fgColor;  // foreground color (0-15) lower 3 rgb bits + intense bit
-        BYTE bgColor;  // background color (0-15) lower 3 rgb bits + intense bit
-        BYTE bold;  // emulated as FOREGROUND_INTENSITY bit
-        BYTE underline;  // emulated as BACKGROUND_INTENSITY bit
-        BOOLEAN inverse;  // swap foreground/bold & background/underline
-        BOOLEAN conceal;  // set foreground/bold to background/underline
-    };
+    return true;
+  }
 
-    enum class AttrColor : BYTE {  // Color attributes for console screen buffer
-        black   = 0,
-        red     = 4,
-        green   = 2,
-        yellow  = 6,
-        blue    = 1,
-        magenta = 5,
-        cyan    = 3,
-        gray    = 7
-    };
+#endif
 
-    inline HANDLE getConsoleHandle(const std::streambuf *osbuf) noexcept
-    {
-        if (osbuf == std::cout.rdbuf()) {
-            static const HANDLE hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
-            return hStdout;
-        } else if (osbuf == std::cerr.rdbuf() || osbuf == std::clog.rdbuf()) {
-            static const HANDLE hStderr = GetStdHandle(STD_ERROR_HANDLE);
-            return hStderr;
-        }
-        return INVALID_HANDLE_VALUE;
+  inline bool isTerminal(const std::streambuf* osbuf) noexcept {
+    using std::cerr;
+    using std::clog;
+    using std::cout;
+#if defined(OS_LINUX) || defined(OS_MAC)
+    if (osbuf == cout.rdbuf()) {
+      static const bool cout_term = isatty(fileno(stdout)) != 0;
+      return cout_term;
+    } else if (osbuf == cerr.rdbuf() || osbuf == clog.rdbuf()) {
+      static const bool cerr_term = isatty(fileno(stderr)) != 0;
+      return cerr_term;
     }
-
-    inline bool setWinTermAnsiColors(const std::streambuf *osbuf) noexcept
-    {
-        HANDLE h = getConsoleHandle(osbuf);
-        if (h == INVALID_HANDLE_VALUE) {
-            return false;
-        }
-        DWORD dwMode = 0;
-        if (!GetConsoleMode(h, &dwMode)) {
-            return false;
-        }
-        dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
-        if (!SetConsoleMode(h, dwMode)) {
-            return false;
-        }
-        return true;
+#elif defined(OS_WIN)
+    if (osbuf == cout.rdbuf()) {
+      static const bool cout_term = (_isatty(_fileno(stdout)) || isMsysPty(_fileno(stdout)));
+      return cout_term;
+    } else if (osbuf == cerr.rdbuf() || osbuf == clog.rdbuf()) {
+      static const bool cerr_term = (_isatty(_fileno(stderr)) || isMsysPty(_fileno(stderr)));
+      return cerr_term;
     }
+#endif
+    return false;
+  }
 
-    inline bool supportsAnsi(const std::streambuf *osbuf) noexcept
-    {
-        using std::cerr;
-        using std::clog;
-        using std::cout;
-        if (osbuf == cout.rdbuf()) {
-            static const bool cout_ansi
-              = (isMsysPty(_fileno(stdout)) || setWinTermAnsiColors(osbuf));
-            return cout_ansi;
-        } else if (osbuf == cerr.rdbuf() || osbuf == clog.rdbuf()) {
-            static const bool cerr_ansi
-              = (isMsysPty(_fileno(stderr)) || setWinTermAnsiColors(osbuf));
-            return cerr_ansi;
-        }
-        return false;
-    }
+  template <typename T>
+  using enableStd = typename std::enable_if<
+      std::is_same<T, rang::style>::value || std::is_same<T, rang::fg>::value ||
+          std::is_same<T, rang::bg>::value || std::is_same<T, rang::fgB>::value ||
+          std::is_same<T, rang::bgB>::value,
+      std::ostream&>::type;
 
-    inline const SGR &defaultState() noexcept
-    {
-        static const SGR defaultSgr = []() -> SGR {
-            CONSOLE_SCREEN_BUFFER_INFO info;
-            WORD attrib = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE;
-            if (GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE),
-                                           &info)
-                || GetConsoleScreenBufferInfo(GetStdHandle(STD_ERROR_HANDLE),
-                                              &info)) {
-                attrib = info.wAttributes;
-            }
-            SGR sgr     = { 0, 0, 0, 0, FALSE, FALSE };
-            sgr.fgColor = attrib & 0x0F;
-            sgr.bgColor = (attrib & 0xF0) >> 4;
-            return sgr;
-        }();
-        return defaultSgr;
-    }
+#ifdef OS_WIN
 
-    inline BYTE ansi2attr(BYTE rgb) noexcept
-    {
-        static const AttrColor rev[8]
-          = { AttrColor::black,  AttrColor::red,  AttrColor::green,
-              AttrColor::yellow, AttrColor::blue, AttrColor::magenta,
-              AttrColor::cyan,   AttrColor::gray };
-        return static_cast<BYTE>(rev[rgb]);
+  struct SGR {          // Select Graphic Rendition parameters for Windows console
+    BYTE    fgColor;    // foreground color (0-15) lower 3 rgb bits + intense bit
+    BYTE    bgColor;    // background color (0-15) lower 3 rgb bits + intense bit
+    BYTE    bold;       // emulated as FOREGROUND_INTENSITY bit
+    BYTE    underline;  // emulated as BACKGROUND_INTENSITY bit
+    BOOLEAN inverse;    // swap foreground/bold & background/underline
+    BOOLEAN conceal;    // set foreground/bold to background/underline
+  };
+
+  enum class AttrColor : BYTE {  // Color attributes for console screen buffer
+    black   = 0,
+    red     = 4,
+    green   = 2,
+    yellow  = 6,
+    blue    = 1,
+    magenta = 5,
+    cyan    = 3,
+    gray    = 7
+  };
+
+  inline HANDLE getConsoleHandle(const std::streambuf* osbuf) noexcept {
+    if (osbuf == std::cout.rdbuf()) {
+      static const HANDLE hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
+      return hStdout;
+    } else if (osbuf == std::cerr.rdbuf() || osbuf == std::clog.rdbuf()) {
+      static const HANDLE hStderr = GetStdHandle(STD_ERROR_HANDLE);
+      return hStderr;
     }
+    return INVALID_HANDLE_VALUE;
+  }
 
-    inline void setWinSGR(rang::bg col, SGR &state) noexcept
-    {
-        if (col != rang::bg::reset) {
-            state.bgColor = ansi2attr(static_cast<BYTE>(col) - 40);
-        } else {
-            state.bgColor = defaultState().bgColor;
-        }
+  inline bool setWinTermAnsiColors(const std::streambuf* osbuf) noexcept {
+    HANDLE h = getConsoleHandle(osbuf);
+    if (h == INVALID_HANDLE_VALUE) {
+      return false;
     }
-
-    inline void setWinSGR(rang::fg col, SGR &state) noexcept
-    {
-        if (col != rang::fg::reset) {
-            state.fgColor = ansi2attr(static_cast<BYTE>(col) - 30);
-        } else {
-            state.fgColor = defaultState().fgColor;
-        }
+    DWORD dwMode = 0;
+    if (!GetConsoleMode(h, &dwMode)) {
+      return false;
     }
-
-    inline void setWinSGR(rang::bgB col, SGR &state) noexcept
-    {
-        state.bgColor = (BACKGROUND_INTENSITY >> 4)
-          | ansi2attr(static_cast<BYTE>(col) - 100);
+    dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
+    if (!SetConsoleMode(h, dwMode)) {
+      return false;
     }
-
-    inline void setWinSGR(rang::fgB col, SGR &state) noexcept
-    {
-        state.fgColor
-          = FOREGROUND_INTENSITY | ansi2attr(static_cast<BYTE>(col) - 90);
+    return true;
+  }
+
+  inline bool supportsAnsi(const std::streambuf* osbuf) noexcept {
+    using std::cerr;
+    using std::clog;
+    using std::cout;
+    if (osbuf == cout.rdbuf()) {
+      static const bool cout_ansi = (isMsysPty(_fileno(stdout)) || setWinTermAnsiColors(osbuf));
+      return cout_ansi;
+    } else if (osbuf == cerr.rdbuf() || osbuf == clog.rdbuf()) {
+      static const bool cerr_ansi = (isMsysPty(_fileno(stderr)) || setWinTermAnsiColors(osbuf));
+      return cerr_ansi;
     }
-
-    inline void setWinSGR(rang::style style, SGR &state) noexcept
-    {
-        switch (style) {
-            case rang::style::reset: state = defaultState(); break;
-            case rang::style::bold: state.bold = FOREGROUND_INTENSITY; break;
-            case rang::style::underline:
-            case rang::style::blink:
-                state.underline = BACKGROUND_INTENSITY;
-                break;
-            case rang::style::reversed: state.inverse = TRUE; break;
-            case rang::style::conceal: state.conceal = TRUE; break;
-            default: break;
-        }
+    return false;
+  }
+
+  inline const SGR& defaultState() noexcept {
+    static const SGR defaultSgr = []() -> SGR {
+      CONSOLE_SCREEN_BUFFER_INFO info;
+      WORD                       attrib = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE;
+      if (GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &info) ||
+          GetConsoleScreenBufferInfo(GetStdHandle(STD_ERROR_HANDLE), &info)) {
+        attrib = info.wAttributes;
+      }
+      SGR sgr     = {0, 0, 0, 0, FALSE, FALSE};
+      sgr.fgColor = attrib & 0x0F;
+      sgr.bgColor = (attrib & 0xF0) >> 4;
+      return sgr;
+    }();
+    return defaultSgr;
+  }
+
+  inline BYTE ansi2attr(BYTE rgb) noexcept {
+    static const AttrColor rev[8] = {AttrColor::black,  AttrColor::red,  AttrColor::green,
+                                     AttrColor::yellow, AttrColor::blue, AttrColor::magenta,
+                                     AttrColor::cyan,   AttrColor::gray};
+    return static_cast<BYTE>(rev[rgb]);
+  }
+
+  inline void setWinSGR(rang::bg col, SGR& state) noexcept {
+    if (col != rang::bg::reset) {
+      state.bgColor = ansi2attr(static_cast<BYTE>(col) - 40);
+    } else {
+      state.bgColor = defaultState().bgColor;
     }
+  }
 
-    inline SGR &current_state() noexcept
-    {
-        static SGR state = defaultState();
-        return state;
+  inline void setWinSGR(rang::fg col, SGR& state) noexcept {
+    if (col != rang::fg::reset) {
+      state.fgColor = ansi2attr(static_cast<BYTE>(col) - 30);
+    } else {
+      state.fgColor = defaultState().fgColor;
     }
-
-    inline WORD SGR2Attr(const SGR &state) noexcept
-    {
-        WORD attrib = 0;
-        if (state.conceal) {
-            if (state.inverse) {
-                attrib = (state.fgColor << 4) | state.fgColor;
-                if (state.bold)
-                    attrib |= FOREGROUND_INTENSITY | BACKGROUND_INTENSITY;
-            } else {
-                attrib = (state.bgColor << 4) | state.bgColor;
-                if (state.underline)
-                    attrib |= FOREGROUND_INTENSITY | BACKGROUND_INTENSITY;
-            }
-        } else if (state.inverse) {
-            attrib = (state.fgColor << 4) | state.bgColor;
-            if (state.bold) attrib |= BACKGROUND_INTENSITY;
-            if (state.underline) attrib |= FOREGROUND_INTENSITY;
-        } else {
-            attrib = state.fgColor | (state.bgColor << 4) | state.bold
-              | state.underline;
-        }
-        return attrib;
+  }
+
+  inline void setWinSGR(rang::bgB col, SGR& state) noexcept {
+    state.bgColor = (BACKGROUND_INTENSITY >> 4) | ansi2attr(static_cast<BYTE>(col) - 100);
+  }
+
+  inline void setWinSGR(rang::fgB col, SGR& state) noexcept {
+    state.fgColor = FOREGROUND_INTENSITY | ansi2attr(static_cast<BYTE>(col) - 90);
+  }
+
+  inline void setWinSGR(rang::style style, SGR& state) noexcept {
+    switch (style) {
+      case rang::style::reset:
+        state = defaultState();
+        break;
+      case rang::style::bold:
+        state.bold = FOREGROUND_INTENSITY;
+        break;
+      case rang::style::underline:
+      case rang::style::blink:
+        state.underline = BACKGROUND_INTENSITY;
+        break;
+      case rang::style::reversed:
+        state.inverse = TRUE;
+        break;
+      case rang::style::conceal:
+        state.conceal = TRUE;
+        break;
+      default:
+        break;
     }
-
-    template <typename T>
-    inline void setWinColorAnsi(std::ostream &os, T const value)
-    {
-        os << "\033[" << static_cast<int>(value) << "m";
+  }
+
+  inline SGR& current_state() noexcept {
+    static SGR state = defaultState();
+    return state;
+  }
+
+  inline WORD SGR2Attr(const SGR& state) noexcept {
+    WORD attrib = 0;
+    if (state.conceal) {
+      if (state.inverse) {
+        attrib = (state.fgColor << 4) | state.fgColor;
+        if (state.bold) attrib |= FOREGROUND_INTENSITY | BACKGROUND_INTENSITY;
+      } else {
+        attrib = (state.bgColor << 4) | state.bgColor;
+        if (state.underline) attrib |= FOREGROUND_INTENSITY | BACKGROUND_INTENSITY;
+      }
+    } else if (state.inverse) {
+      attrib = (state.fgColor << 4) | state.bgColor;
+      if (state.bold) attrib |= BACKGROUND_INTENSITY;
+      if (state.underline) attrib |= FOREGROUND_INTENSITY;
+    } else {
+      attrib = state.fgColor | (state.bgColor << 4) | state.bold | state.underline;
     }
-
-    template <typename T>
-    inline void setWinColorNative(std::ostream &os, T const value)
-    {
-        const HANDLE h = getConsoleHandle(os.rdbuf());
-        if (h != INVALID_HANDLE_VALUE) {
-            setWinSGR(value, current_state());
-            // Out all buffered text to console with previous settings:
-            os.flush();
-            SetConsoleTextAttribute(h, SGR2Attr(current_state()));
-        }
+    return attrib;
+  }
+
+  template <typename T>
+  inline void setWinColorAnsi(std::ostream& os, T const value) {
+    os << "\033[" << static_cast<int>(value) << "m";
+  }
+
+  template <typename T>
+  inline void setWinColorNative(std::ostream& os, T const value) {
+    const HANDLE h = getConsoleHandle(os.rdbuf());
+    if (h != INVALID_HANDLE_VALUE) {
+      setWinSGR(value, current_state());
+      // Out all buffered text to console with previous settings:
+      os.flush();
+      SetConsoleTextAttribute(h, SGR2Attr(current_state()));
     }
-
-    template <typename T>
-    inline enableStd<T> setColor(std::ostream &os, T const value)
-    {
-        if (winTermMode() == winTerm::Auto) {
-            if (supportsAnsi(os.rdbuf())) {
-                setWinColorAnsi(os, value);
-            } else {
-                setWinColorNative(os, value);
-            }
-        } else if (winTermMode() == winTerm::Ansi) {
-            setWinColorAnsi(os, value);
-        } else {
-            setWinColorNative(os, value);
-        }
-        return os;
+  }
+
+  template <typename T>
+  inline enableStd<T> setColor(std::ostream& os, T const value) {
+    if (winTermMode() == winTerm::Auto) {
+      if (supportsAnsi(os.rdbuf())) {
+        setWinColorAnsi(os, value);
+      } else {
+        setWinColorNative(os, value);
+      }
+    } else if (winTermMode() == winTerm::Ansi) {
+      setWinColorAnsi(os, value);
+    } else {
+      setWinColorNative(os, value);
     }
+    return os;
+  }
 #else
-    template <typename T>
-    inline enableStd<T> setColor(std::ostream &os, T const value)
-    {
-        return os << "\033[" << static_cast<int>(value) << "m";
-    }
+  template <typename T>
+  inline enableStd<T> setColor(std::ostream& os, T const value) {
+    return os << "\033[" << static_cast<int>(value) << "m";
+  }
 #endif
 }  // namespace rang_implementation
 
 template <typename T>
-inline rang_implementation::enableStd<T> operator<<(std::ostream &os,
-                                                    const T value)
-{
-    const control option = rang_implementation::controlMode();
-    switch (option) {
-        case control::Auto:
-            return rang_implementation::supportsColor()
-                && rang_implementation::isTerminal(os.rdbuf())
-              ? rang_implementation::setColor(os, value)
-              : os;
-        case control::Force: return rang_implementation::setColor(os, value);
-        default: return os;
-    }
+inline rang_implementation::enableStd<T> operator<<(std::ostream& os, const T value) {
+  const control option = rang_implementation::controlMode();
+  switch (option) {
+    case control::Auto:
+      return rang_implementation::supportsColor() && rang_implementation::isTerminal(os.rdbuf())
+                 ? rang_implementation::setColor(os, value)
+                 : os;
+    case control::Force:
+      return rang_implementation::setColor(os, value);
+    default:
+      return os;
+  }
 }
 
-inline void setWinTermMode(const rang::winTerm value) noexcept
-{
-    rang_implementation::winTermMode() = value;
+inline void setWinTermMode(const rang::winTerm value) noexcept {
+  rang_implementation::winTermMode() = value;
 }
 
-inline void setControlMode(const control value) noexcept
-{
-    rang_implementation::controlMode() = value;
+inline void setControlMode(const control value) noexcept {
+  rang_implementation::controlMode() = value;
 }
 
 }  // namespace rang
-- 
cgit v1.2.3


From 4aec90bf2110e21412fa10435f83a04a01ee24df Mon Sep 17 00:00:00 2001
From: Amlal <amlal@nekernel.org>
Date: Fri, 2 May 2025 10:37:13 +0200
Subject: kernel, fskit: HeFS: Worked on IND allocation and added removal
 support.

notice:
 - parent_dir_fmt has to be formated to take care of subdirs.

Signed-off-by: Amlal <amlal@nekernel.org>
---
 dev/kernel/FSKit/HeFS.h      |  16 +++-
 dev/kernel/src/FS/HeFS.cc    | 192 +++++++++++++++++++++++++++++++------------
 dev/kernel/src/PEFCodeMgr.cc |   1 -
 3 files changed, 150 insertions(+), 59 deletions(-)

(limited to 'dev/kernel/src/PEFCodeMgr.cc')

diff --git a/dev/kernel/FSKit/HeFS.h b/dev/kernel/FSKit/HeFS.h
index da5da3c1..50b8e259 100644
--- a/dev/kernel/FSKit/HeFS.h
+++ b/dev/kernel/FSKit/HeFS.h
@@ -358,14 +358,22 @@ class HeFileSystemParser final {
   /// @return If it was sucessful, see err_local_get().
   _Output Bool Format(_Input _Output DriveTrait* drive, _Input const Int32 flags,
                       const Utf8Char* part_name);
-
+ 
   _Output Bool CreateDirectory(_Input DriveTrait* drive, _Input const Int32 flags,
-                               const Utf8Char* dir);
+    const Utf8Char* dir, const Utf8Char* parent_dir);
+
+    
+  _Output Bool RemoveDirectory(_Input DriveTrait* drive, _Input const Int32 flags,
+    const Utf8Char* dir, const Utf8Char* parent_dir);
 
-  _Output Bool CreateFile(_Input DriveTrait* drive, _Input const Int32 flags, const Utf8Char* dir,
+  _Output Bool CreateFile(_Input DriveTrait* drive, _Input const Int32 flags, const Utf8Char* dir, const Utf8Char* namespase,
                           const Utf8Char* name);
 
- public:
+ private:
+ 
+ _Output Bool DirectoryCtl_(_Input DriveTrait* drive, _Input const Int32 flags,
+  const Utf8Char* dir, const Utf8Char* parent, const BOOL delete_or_create);
+
   UInt32 mDriveIndex{MountpointInterface::kDriveIndexA};  /// @brief The drive index which this
                                                           /// filesystem is mounted on.
 };
diff --git a/dev/kernel/src/FS/HeFS.cc b/dev/kernel/src/FS/HeFS.cc
index 695752af..4cea6f58 100644
--- a/dev/kernel/src/FS/HeFS.cc
+++ b/dev/kernel/src/FS/HeFS.cc
@@ -67,8 +67,7 @@ namespace Detail {
   /// @param root The root node of the filesystem.
   /// @param mnt The drive to read/write from.
   /// @return Status, see err_global_get().
-  STATIC ATTRIBUTE(unused) _Output BOOL
-      hefsi_balance_filesystem(HEFS_BOOT_NODE* root, DriveTrait* mnt);
+  STATIC ATTRIBUTE(unused) _Output BOOL hefsi_balance_ind(HEFS_BOOT_NODE* root, DriveTrait* mnt);
 
   /// @brief Traverse the RB-Tree of the filesystem.
   /// @param dir The directory to traverse.
@@ -88,11 +87,9 @@ namespace Detail {
       mnt->fPacket.fPacketContent = dir;
       mnt->fInput(mnt->fPacket);
 
-      if (!mnt->fPacket.fPacketGood)
-        break;
+      if (!mnt->fPacket.fPacketGood) break;
 
-      if (*dir->fName != 0 && alloc_in_mind)
-        break;
+      if (*dir->fName != 0 && alloc_in_mind) break;
 
       if (dir->fNext != 0) {
         if (check_is_good) break;
@@ -134,10 +131,9 @@ namespace Detail {
       }
     }
 
-    if (*dir->fName != 0 && alloc_in_mind)
-      start += sizeof(HEFS_INDEX_NODE_DIRECTORY);
+    if (*dir->fName != 0 && alloc_in_mind) start += sizeof(HEFS_INDEX_NODE_DIRECTORY);
 
-    kout << "LBA_" << number(start) << kendl;
+    (Void)(kout << "LBA_" << number(start) << kendl);
   }
 
   /***********************************************************************************/
@@ -279,10 +275,17 @@ namespace Detail {
     return 0;
   }
 
-  /// @brief Alllocate IND for boot node.
-  STATIC _Output BOOL hefsi_allocate_index_node_directory(HEFS_BOOT_NODE* root, DriveTrait* mnt,
-                                                          const Utf8Char* dir_name,
-                                                          UInt16          flags) noexcept {
+  /// @brief Alllocate IND from boot node.
+  /// @param root The root node of the filesystem.
+  /// @param mnt The drive to read from.
+  /// @param dir_name The name of the directory.
+  /// @param dir_name The parent of the directory.
+  /// @param flags Directory flags.
+  /// @param delete_or_create Delete or create directory.
+  STATIC _Output BOOL hefsi_update_ind_status(HEFS_BOOT_NODE* root, DriveTrait* mnt,
+                                              const Utf8Char* dir_name,
+                                              const Utf8Char* parent_dir_fmt, UInt16 flags,
+                                              const BOOL delete_or_create) noexcept {
     if (urt_string_len(dir_name) >= kHeFSFileNameLen) {
       err_global_get() = kErrorDisk;
       return NO;
@@ -292,13 +295,14 @@ namespace Detail {
       HEFS_INDEX_NODE_DIRECTORY* tmpdir =
           (HEFS_INDEX_NODE_DIRECTORY*) mm_new_heap(sizeof(HEFS_INDEX_NODE_DIRECTORY), Yes, No);
 
-      auto start         = root->fStartIND;
-      auto prev_location = start;
+      auto start           = root->fStartIND;
+      auto prev_location   = start;
+      auto parent_location = 0UL;
 
       MUST_PASS(root->fStartIND > mnt->fLbaStart);
 
       while (YES) {
-        auto tmp = start;
+        auto prev_start = start;
 
         if (start)
           mnt->fPacket.fPacketLba = start;
@@ -310,17 +314,41 @@ namespace Detail {
 
         mnt->fInput(mnt->fPacket);
 
-        if ((!tmpdir->fCreated && tmpdir->fDeleted) || *tmpdir->fName == 0) {
+        BOOL expr = NO;
+
+        if (!delete_or_create) {
+          expr = (!tmpdir->fCreated && tmpdir->fDeleted) || *tmpdir->fName == 0;
+        } else {
+          expr = tmpdir->fCreated && !tmpdir->fDeleted &&
+                 KStringBuilder::Equals(tmpdir->fName, dir_name);
+
+          if (parent_dir_fmt && !delete_or_create && !parent_location) {
+            if (KStringBuilder::Equals(tmpdir->fName, parent_dir_fmt)) {
+              if (tmpdir->fChild == 0) {
+                ke_panic(RUNTIME_CHECK_FILESYSTEM,
+                         "Filesystem has a corrupted child entry on RB-Tree IND.");
+              } else {
+                parent_location = start;
+                continue;
+              }
+            }
+          }
+        }
+
+        if (expr) {
           HEFS_INDEX_NODE_DIRECTORY* dirent =
               (HEFS_INDEX_NODE_DIRECTORY*) mm_new_heap(sizeof(HEFS_INDEX_NODE_DIRECTORY), Yes, No);
 
-          urt_copy_memory((VoidPtr) dir_name, dirent->fName, urt_string_len(dir_name) + 1);
+          rt_set_memory(dirent, 0, sizeof(HEFS_INDEX_NODE_DIRECTORY));
 
-          dirent->fAccessed   = 0;
-          dirent->fCreated    = 1UL;
-          dirent->fDeleted    = 0;
-          dirent->fModified   = 0;
-          dirent->fEntryCount = 0;
+          if (!delete_or_create)
+            urt_copy_memory((VoidPtr) dir_name, dirent->fName, urt_string_len(dir_name) + 1);
+
+          dirent->fAccessed   = 0UL;
+          dirent->fCreated    = delete_or_create ? 0UL : 1UL;
+          dirent->fDeleted    = delete_or_create ? 1UL : 0UL;
+          dirent->fModified   = 0UL;
+          dirent->fEntryCount = 0UL;
 
           dirent->fKind     = kHeFSFileKindDirectory;
           dirent->fFlags    = flags;
@@ -328,6 +356,48 @@ namespace Detail {
 
           dirent->fEntryCount = 0;
 
+          if (parent_location) {
+            HEFS_INDEX_NODE_DIRECTORY* tmpend =
+                (HEFS_INDEX_NODE_DIRECTORY*) RTL_ALLOCA(sizeof(HEFS_INDEX_NODE_DIRECTORY));
+
+            mnt->fPacket.fPacketLba     = parent_location;
+            mnt->fPacket.fPacketSize    = sizeof(HEFS_INDEX_NODE_DIRECTORY);
+            mnt->fPacket.fPacketContent = tmpend;
+
+            mnt->fInput(mnt->fPacket);
+
+            if (tmpend->fChecksum !=
+                ke_calculate_crc32((Char*) tmpend, sizeof(HEFS_INDEX_NODE_DIRECTORY)))
+              ke_panic(RUNTIME_CHECK_FILESYSTEM, "Bad CRC32");
+
+            if (delete_or_create)
+              --tmpend->fEntryCount;
+            else
+              ++tmpend->fEntryCount;
+
+            tmpend->fChecksum =
+                ke_calculate_crc32((Char*) tmpend, sizeof(HEFS_INDEX_NODE_DIRECTORY));
+
+            mnt->fOutput(mnt->fPacket);
+
+            auto child_first = tmpend->fChild;
+
+            while (YES) {
+              mnt->fPacket.fPacketLba     = child_first;
+              mnt->fPacket.fPacketSize    = sizeof(HEFS_INDEX_NODE_DIRECTORY);
+              mnt->fPacket.fPacketContent = tmpend;
+
+              mnt->fInput(mnt->fPacket);
+
+              if ((!tmpend->fCreated && tmpend->fDeleted) || *tmpend->fName == 0) {
+                start = child_first;
+                break;
+              }
+
+              hefsi_traverse_tree(tmpend, mnt, root->fStartIND, child_first, YES);
+            }
+          }
+
           dirent->fNext   = tmpdir->fNext;
           dirent->fPrev   = tmpdir->fPrev;
           dirent->fParent = tmpdir->fParent;
@@ -343,7 +413,7 @@ namespace Detail {
           }
 
           if (dirent->fNext == 0) {
-            dirent->fNext = tmp + sizeof(HEFS_INDEX_NODE_DIRECTORY);
+            dirent->fNext = prev_start + sizeof(HEFS_INDEX_NODE_DIRECTORY);
           }
 
           if (dirent->fParent == 0) {
@@ -384,7 +454,7 @@ namespace Detail {
 
           dirent->fChecksum = ke_calculate_crc32((Char*) dirent, sizeof(HEFS_INDEX_NODE_DIRECTORY));
 
-          mnt->fPacket.fPacketLba     = tmp;
+          mnt->fPacket.fPacketLba     = prev_start;
           mnt->fPacket.fPacketSize    = sizeof(HEFS_INDEX_NODE_DIRECTORY);
           mnt->fPacket.fPacketContent = dirent;
 
@@ -395,7 +465,10 @@ namespace Detail {
           mm_delete_heap(dirent);
           mm_delete_heap(tmpdir);
 
-          ++root->fINDCount;
+          if (!delete_or_create)
+            ++root->fINDCount;
+          else
+            --root->fINDCount;
 
           mnt->fPacket.fPacketLba     = mnt->fLbaStart;
           mnt->fPacket.fPacketSize    = sizeof(HEFS_BOOT_NODE);
@@ -422,8 +495,12 @@ namespace Detail {
     return NO;
   }
 
-  STATIC _Output HEFS_INDEX_NODE_DIRECTORY* hefsi_fetch_index_node_directory(
-      HEFS_BOOT_NODE* root, DriveTrait* mnt, const Utf8Char* dir_name) {
+  /// @brief Fetch IND from boot node.
+  /// @param root The root node of the filesystem.
+  /// @param mnt The drive to read from.
+  /// @param dir_name The name of the directory.
+  STATIC _Output HEFS_INDEX_NODE_DIRECTORY* hefsi_fetch_ind(HEFS_BOOT_NODE* root, DriveTrait* mnt,
+                                                            const Utf8Char* dir_name) {
     if (mnt) {
       HEFS_INDEX_NODE_DIRECTORY* dir =
           (HEFS_INDEX_NODE_DIRECTORY*) RTL_ALLOCA(sizeof(HEFS_INDEX_NODE_DIRECTORY));
@@ -608,12 +685,11 @@ namespace Detail {
   /// @param root The root node of the filesystem.
   /// @param mnt The drive to read/write from.
   /// @return Status, see err_global_get().
-  STATIC ATTRIBUTE(unused) _Output BOOL
-      hefsi_balance_filesystem(HEFS_BOOT_NODE* root, DriveTrait* mnt) {
+  STATIC ATTRIBUTE(unused) _Output BOOL hefsi_balance_ind(HEFS_BOOT_NODE* root, DriveTrait* mnt) {
     if (mnt) {
       HEFS_INDEX_NODE_DIRECTORY* dir =
           (HEFS_INDEX_NODE_DIRECTORY*) RTL_ALLOCA(sizeof(HEFS_INDEX_NODE_DIRECTORY));
-      HEFS_INDEX_NODE_DIRECTORY* dir_parent =
+      HEFS_INDEX_NODE_DIRECTORY* parent_dir_fmt =
           (HEFS_INDEX_NODE_DIRECTORY*) RTL_ALLOCA(sizeof(HEFS_INDEX_NODE_DIRECTORY));
 
       auto start = root->fStartIND;
@@ -655,7 +731,7 @@ namespace Detail {
 
         mnt->fPacket.fPacketLba     = dir->fParent;
         mnt->fPacket.fPacketSize    = sizeof(HEFS_INDEX_NODE_DIRECTORY);
-        mnt->fPacket.fPacketContent = dir_parent;
+        mnt->fPacket.fPacketContent = parent_dir_fmt;
 
         mnt->fInput(mnt->fPacket);
 
@@ -668,7 +744,7 @@ namespace Detail {
         HEFS_INDEX_NODE_DIRECTORY* dir_uncle =
             (HEFS_INDEX_NODE_DIRECTORY*) RTL_ALLOCA(sizeof(HEFS_INDEX_NODE_DIRECTORY));
 
-        mnt->fPacket.fPacketLba     = dir_parent->fNext;
+        mnt->fPacket.fPacketLba     = parent_dir_fmt->fNext;
         mnt->fPacket.fPacketSize    = sizeof(HEFS_INDEX_NODE_DIRECTORY);
         mnt->fPacket.fPacketContent = dir_uncle;
 
@@ -680,23 +756,23 @@ namespace Detail {
           return NO;
         }
 
-        if (dir_parent->fNext == start) {
+        if (parent_dir_fmt->fNext == start) {
           hefsi_rotate_tree(start, mnt, YES);
-          hefsi_traverse_tree(dir_parent, mnt, root->fStartIND, start);
+          hefsi_traverse_tree(parent_dir_fmt, mnt, root->fStartIND, start);
 
           if (start > root->fEndIND || start == 0) break;
 
           continue;
         }
 
-        dir_parent->fColor = kHeFSBlack;
+        parent_dir_fmt->fColor = kHeFSBlack;
 
-        dir_parent->fChecksum =
-            ke_calculate_crc32((Char*) dir_parent, sizeof(HEFS_INDEX_NODE_DIRECTORY));
+        parent_dir_fmt->fChecksum =
+            ke_calculate_crc32((Char*) parent_dir_fmt, sizeof(HEFS_INDEX_NODE_DIRECTORY));
 
         mnt->fPacket.fPacketLba     = dir->fParent;
         mnt->fPacket.fPacketSize    = sizeof(HEFS_INDEX_NODE_DIRECTORY);
-        mnt->fPacket.fPacketContent = dir_parent;
+        mnt->fPacket.fPacketContent = parent_dir_fmt;
 
         mnt->fOutput(mnt->fPacket);
 
@@ -851,11 +927,11 @@ _Output Bool HeFileSystemParser::Format(_Input _Output DriveTrait* drive, _Input
   }
 
   const Utf8Char* kFileMap[kHeFSPreallocateCount] = {
-      u8"/", u8"/boot", u8"/system", u8"/network", u8"/devices", u8"/media", u8"/vm",
+      u8"/", u8"boot", u8"system", u8"network", u8"devices", u8"media", u8"vm",
   };
 
   for (SizeT i = 0; i < kHeFSPreallocateCount; ++i) {
-    this->CreateDirectory(drive, kHeFSEncodingUTF8, kFileMap[i]);
+    this->CreateDirectory(drive, kHeFSEncodingUTF8, kFileMap[i], (i == 0) ? nullptr : u8"/");
   }
 
   err_global_get() = kErrorSuccess;
@@ -872,8 +948,9 @@ _Output Bool HeFileSystemParser::Format(_Input _Output DriveTrait* drive, _Input
 /// @param flags The flags to use.
 /// @param dir The directory to create the file in.
 /// @return If it was sucessful, see err_local_get().
-_Output Bool HeFileSystemParser::CreateDirectory(_Input DriveTrait* drive, _Input const Int32 flags,
-                                                 const Utf8Char* dir) {
+_Output Bool HeFileSystemParser::DirectoryCtl_(_Input DriveTrait* drive, _Input const Int32 flags,
+                                               const Utf8Char* dir, const Utf8Char* parent_dir,
+                                               const BOOL delete_or_create) {
   HEFS_BOOT_NODE* root = (HEFS_BOOT_NODE*) mm_new_heap(sizeof(HEFS_BOOT_NODE), Yes, No);
 
   rt_copy_memory((VoidPtr) "fs/hefs-packet", drive->fPacket.fPacketMime,
@@ -893,24 +970,28 @@ _Output Bool HeFileSystemParser::CreateDirectory(_Input DriveTrait* drive, _Inpu
     return NO;
   }
 
-  auto name = new Utf8Char[urt_string_len(dir) + 1];
-
-  urt_copy_memory((VoidPtr) dir, name, urt_string_len(dir) + 1);
-
-  if (Detail::hefsi_allocate_index_node_directory(root, drive, name, flags)) {
+  if (Detail::hefsi_update_ind_status(root, drive, dir, parent_dir, flags, delete_or_create)) {
     // todo: make it smarter for high-throughput.
-    Detail::hefsi_balance_filesystem(root, drive);
+    Detail::hefsi_balance_ind(root, drive);
 
     mm_delete_heap((VoidPtr) root);
-    delete[] name;
     return YES;
   }
 
   mm_delete_heap((VoidPtr) root);
+  return NO;
+}
 
-  delete[] name;
+_Output Bool HeFileSystemParser::RemoveDirectory(_Input DriveTrait* drive, _Input const Int32 flags,
+                                                 const Utf8Char* dir,
+                                                 const Utf8Char* parent_dir_fmt) {
+  return this->DirectoryCtl_(drive, flags, dir, parent_dir_fmt, YES);
+}
 
-  return NO;
+_Output Bool HeFileSystemParser::CreateDirectory(_Input DriveTrait* drive, _Input const Int32 flags,
+                                                 const Utf8Char* dir,
+                                                 const Utf8Char* parent_dir_fmt) {
+  return this->DirectoryCtl_(drive, flags, dir, parent_dir_fmt, NO);
 }
 
 /// @brief Create a new file on the disk.
@@ -920,7 +1001,10 @@ _Output Bool HeFileSystemParser::CreateDirectory(_Input DriveTrait* drive, _Inpu
 /// @param name The name of the file.
 /// @return If it was sucessful, see err_local_get().
 _Output Bool HeFileSystemParser::CreateFile(_Input DriveTrait* drive, _Input const Int32 flags,
-                                            const Utf8Char* dir, const Utf8Char* name) {
+                                            const Utf8Char* dir, const Utf8Char* parent_dir_fmt,
+                                            const Utf8Char* name) {
+  NE_UNUSED(parent_dir_fmt);
+
   HEFS_INDEX_NODE* node = (HEFS_INDEX_NODE*) RTL_ALLOCA(sizeof(HEFS_INDEX_NODE));
   HEFS_BOOT_NODE*  root = (HEFS_BOOT_NODE*) RTL_ALLOCA(sizeof(HEFS_BOOT_NODE));
 
@@ -933,7 +1017,7 @@ _Output Bool HeFileSystemParser::CreateFile(_Input DriveTrait* drive, _Input con
 
   drive->fInput(drive->fPacket);
 
-  if (!Detail::hefsi_fetch_index_node_directory(root, drive, dir)->fCreated) return NO;
+  if (!Detail::hefsi_fetch_ind(root, drive, dir)->fCreated) return NO;
 
   if (KStringBuilder::Equals(name, kHeFSSearchAllStr)) {
     kout << "Error: Invalid file name.\r";
diff --git a/dev/kernel/src/PEFCodeMgr.cc b/dev/kernel/src/PEFCodeMgr.cc
index 5da3a499..09a262d4 100644
--- a/dev/kernel/src/PEFCodeMgr.cc
+++ b/dev/kernel/src/PEFCodeMgr.cc
@@ -12,7 +12,6 @@
 #include <NewKit/KString.h>
 #include <NewKit/KernelPanic.h>
 #include <NewKit/OwnPtr.h>
-#include "KernelKit/UserProcessScheduler.h"
 
 /// @brief PEF stack size symbol.
 #define kPefStackSizeSymbol "__PEFSizeOfReserveStack"
-- 
cgit v1.2.3