kernel!: lots of changes, see commit details.

refactor(hal): unify file naming and drop redundant architecture suffixes

feat(build): rename kernel and bootloader to 'ne_kernel' and 'ne_bootz'

refactor(memory): replace mm_get_phys_address with mm_get_page_addr

feat(bitmap): track bitmap allocator usage and add out-of-memory error

fix(heap): correct heap magic naming and alignment logic

chore(fs): downgrade HeFS disk size check to warning

chore(tools): clean up formatting in 'ping' and 'manual'

docs(design): update OS_DESIGN.drawio to reflect Hypr86 and new layout

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

5 files changed, 29 insertions, 16 deletions

diff --git a/dev/kernel/src/BitMapMgr.cc b/dev/kernel/src/BitMapMgr.cc
index 4301ce5b..df678d41 100644
--- a/dev/kernel/src/BitMapMgr.cc
+++ b/dev/kernel/src/BitMapMgr.cc
@@ -22,6 +22,8 @@
 namespace Kernel {
 namespace HAL {
   namespace Detail {
+    STATIC SizeT kBitMapCursor = 0UL;
+
     /***********************************************************************************/
     /// \brief Proxy Interface to manage a bitmap allocator.
     /***********************************************************************************/
@@ -47,6 +49,8 @@ namespace HAL {
 
         UIntPtr* ptr_bit_set = reinterpret_cast<UIntPtr*>(page_ptr);
 
+        kBitMapCursor += ptr_bit_set[kBitMapSizeIdx];
+
         ptr_bit_set[kBitMapMagIdx]  = kBitMapMagic;
         ptr_bit_set[kBitMapUsedIdx] = No;
 
@@ -59,7 +63,6 @@ namespace HAL {
         UInt32 flags = kMMFlagsPresent;
 
         if (wr) flags |= kMMFlagsWr;
-
         if (user) flags |= kMMFlagsUser;
 
         return flags;
@@ -77,11 +80,18 @@ namespace HAL {
       auto FindBitMap(VoidPtr base_ptr, SizeT size, Bool wr, Bool user, SizeT pad) -> VoidPtr {
         if (!size) return nullptr;
 
+        if (kBitMapCursor > kKernelBitMpSize) {
+          err_global_get() = kErrorOutOfBitMapMemory;
+
+          (Void)(kout << "Bitmap limit reached, can't allocate more bitmaps." << kendl);
+          return nullptr;
+        }
+
         VoidPtr base = reinterpret_cast<VoidPtr>((UIntPtr) base_ptr);
 
         MUST_PASS(base);
 
-        static SizeT biggest = 0UL;
+        STATIC SizeT biggest = 0UL;
 
         while (YES) {
           UIntPtr* ptr_bit_set = reinterpret_cast<UIntPtr*>(base);
@@ -99,6 +109,8 @@ namespace HAL {
 
               if (biggest < (size + pad)) biggest = size + pad;
 
+              kBitMapCursor += size + pad;
+
               return (VoidPtr) ptr_bit_set;
             }
           } else if (ptr_bit_set[kBitMapMagIdx] != kBitMapMagic) {
@@ -113,6 +125,8 @@ namespace HAL {
 
             if (biggest < (size + pad)) biggest = (size + pad);
 
+            kBitMapCursor += size + pad;
+
             return (VoidPtr) ptr_bit_set;
           }
 
diff --git a/dev/kernel/src/FS/HeFS+FileSystemParser.cc b/dev/kernel/src/FS/HeFS+FileSystemParser.cc
index a18abaf8..893f43ef 100644
--- a/dev/kernel/src/FS/HeFS+FileSystemParser.cc
+++ b/dev/kernel/src/FS/HeFS+FileSystemParser.cc
@@ -758,9 +758,8 @@ _Output Bool HeFileSystemParser::Format(_Input _Output DriveTrait* mnt, _Input c
   }
 
   if (drv_std_get_size() < kHeFSMinimumDiskSize) {
-    (Void)(kout << "HeFS requires at least 128 GiB of free space." << kendl);
-    err_global_get() = kErrorDisk;
-    return NO;
+    (Void)(kout << "HeFS recommends at least 128 GiB of free space." << kendl);
+    (Void)(kout << "The OS will still try to format a HeFS disk here." << kendl);
   }
 
   HEFS_BOOT_NODE* boot = (HEFS_BOOT_NODE*) RTL_ALLOCA(sizeof(HEFS_BOOT_NODE));
diff --git a/dev/kernel/src/HeapMgr.cc b/dev/kernel/src/HeapMgr.cc
index 5280bcc3..2fdfe748 100644
--- a/dev/kernel/src/HeapMgr.cc
+++ b/dev/kernel/src/HeapMgr.cc
@@ -25,8 +25,8 @@
 //! @file HeapMgr.cc
 //! @brief Heap system that serves as the main memory manager.
 
-#define kMemoryMgrMagic (0xD4D75)
-#define kMemoryMgrAlignSz (4U)
+#define kHeapMgrMagic (0xD4D75)
+#define kHeapMgrAlignSz (4U)
 
 namespace Kernel {
 /// @brief Implementation details.
@@ -68,7 +68,7 @@ namespace Detail {
     UInt32 fPad;
 
     /// @brief Padding bytes for header.
-    UInt8 fPadding[kMemoryMgrAlignSz];
+    UInt8 fPadding[kHeapMgrAlignSz];
   };
 
   /// @brief Check for heap address validity.
@@ -112,7 +112,7 @@ _Output VoidPtr mm_alloc_ptr(SizeT sz, Bool wr, Bool user, SizeT pad_amount) {
                                                          sizeof(Detail::MM_INFORMATION_BLOCK));
 
   heap_info_ptr->fSize  = sz_fix;
-  heap_info_ptr->fMagic = kMemoryMgrMagic;
+  heap_info_ptr->fMagic = kHeapMgrMagic;
   heap_info_ptr->fCRC32 = 0U;  // dont fill it for now.
   heap_info_ptr->fOffset =
       reinterpret_cast<UIntPtr>(heap_info_ptr) + sizeof(Detail::MM_INFORMATION_BLOCK);
@@ -122,7 +122,7 @@ _Output VoidPtr mm_alloc_ptr(SizeT sz, Bool wr, Bool user, SizeT pad_amount) {
   heap_info_ptr->fPresent   = Yes;
   heap_info_ptr->fPad       = pad_amount;
 
-  rt_set_memory(heap_info_ptr->fPadding, 0, kMemoryMgrAlignSz);
+  rt_set_memory(heap_info_ptr->fPadding, 0, kHeapMgrAlignSz);
 
   auto result = reinterpret_cast<VoidPtr>(heap_info_ptr->fOffset);
 
@@ -191,7 +191,7 @@ _Output Int32 mm_free_ptr(VoidPtr heap_ptr) {
       reinterpret_cast<Detail::MM_INFORMATION_BLOCK_PTR>((UIntPtr) (heap_ptr) -
                                                          sizeof(Detail::MM_INFORMATION_BLOCK));
 
-  if (heap_info_ptr && heap_info_ptr->fMagic == kMemoryMgrMagic) {
+  if (heap_info_ptr && heap_info_ptr->fMagic == kHeapMgrMagic) {
     if (!heap_info_ptr->fPresent) {
       return kErrorHeapNotPresent;
     }
@@ -231,7 +231,7 @@ _Output Boolean mm_is_valid_ptr(VoidPtr heap_ptr) {
         reinterpret_cast<Detail::MM_INFORMATION_BLOCK_PTR>((UIntPtr) (heap_ptr) -
                                                            sizeof(Detail::MM_INFORMATION_BLOCK));
 
-    return (heap_info_ptr && heap_info_ptr->fPresent && heap_info_ptr->fMagic == kMemoryMgrMagic);
+    return (heap_info_ptr && heap_info_ptr->fPresent && heap_info_ptr->fMagic == kHeapMgrMagic);
   }
 
   return No;
@@ -247,7 +247,7 @@ _Output Boolean mm_protect_ptr(VoidPtr heap_ptr) {
                                                            sizeof(Detail::MM_INFORMATION_BLOCK));
 
     /// if valid, present and is heap header, then compute crc32
-    if (heap_info_ptr && heap_info_ptr->fPresent && kMemoryMgrMagic == heap_info_ptr->fMagic) {
+    if (heap_info_ptr && heap_info_ptr->fPresent && kHeapMgrMagic == heap_info_ptr->fMagic) {
       heap_info_ptr->fCRC32 =
           ke_calculate_crc32((Char*) heap_info_ptr->fOffset, heap_info_ptr->fSize);
 
diff --git a/dev/kernel/src/PEFCodeMgr.cc b/dev/kernel/src/PEFCodeMgr.cc
index e810651a..ed72473f 100644
--- a/dev/kernel/src/PEFCodeMgr.cc
+++ b/dev/kernel/src/PEFCodeMgr.cc
@@ -161,7 +161,7 @@ ErrorOr<VoidPtr> PEFLoader::FindSymbol(const Char* name, Int32 kind) {
         kout << "PEFLoader: Information: Loaded stub: " << container_header->Name << "!\r";
 
         auto ret = HAL::mm_map_page((VoidPtr) container_header->VMAddress,
-                                    (VoidPtr) HAL::mm_get_phys_address(container_blob_value),
+                                    (VoidPtr) HAL::mm_get_page_addr(container_blob_value),
                                     HAL::kMMFlagsPresent | HAL::kMMFlagsUser);
 
         if (ret != kErrorSuccess) {
diff --git a/dev/kernel/src/UserProcessScheduler.cc b/dev/kernel/src/UserProcessScheduler.cc
index 77421f5f..f900f984 100644
--- a/dev/kernel/src/UserProcessScheduler.cc
+++ b/dev/kernel/src/UserProcessScheduler.cc
@@ -403,10 +403,10 @@ ProcessID UserProcessScheduler::Spawn(const Char* name, VoidPtr code, VoidPtr im
 
 #ifdef __NE_VIRTUAL_MEMORY_SUPPORT__
   HAL::mm_map_page((VoidPtr) process.StackFrame->IP,
-                   (VoidPtr) HAL::mm_get_phys_address((VoidPtr) process.StackFrame->IP),
+                   (VoidPtr) HAL::mm_get_page_addr((VoidPtr) process.StackFrame->IP),
                    HAL::kMMFlagsUser | HAL::kMMFlagsPresent);
   HAL::mm_map_page((VoidPtr) process.StackFrame->SP,
-                   (VoidPtr) HAL::mm_get_phys_address((VoidPtr) process.StackFrame->SP),
+                   (VoidPtr) HAL::mm_get_page_addr((VoidPtr) process.StackFrame->SP),
                    HAL::kMMFlagsUser | HAL::kMMFlagsPresent);
 #endif  // ifdef __NE_VIRTUAL_MEMORY_SUPPORT__