Kernel: See below.

- Fix ACPI.
- Parsing SDT correctly now.
- Fix ke_runtime_check line endings.
- Update Kernel heap magic and add padding to header.
- Document Code Manager add limit for process teams.
- Add execute_from_image for Code Manager.
- Add loop for scheduler inside RuntimeMain.
- Set SMP core to 4 for testing purposes.
- Check for ACPI 2.x+

Signed-off-by: Amlal El Mahrouss <amlal@el-mahrouss-logic.com>

7 files changed, 69 insertions, 23 deletions

diff --git a/Private/Source/CodeManager.cxx b/Private/Source/CodeManager.cxx
new file mode 100644
index 00000000..db2a7017
--- /dev/null
+++ b/Private/Source/CodeManager.cxx
@@ -0,0 +1,26 @@
+/* -------------------------------------------
+
+    Copyright Mahrouss Logic
+
+------------------------------------------- */
+
+#include <NewKit/Utils.hpp>
+#include <KernelKit/CodeManager.hpp>
+#include <KernelKit/ProcessScheduler.hpp>
+
+using namespace NewOS;
+
+/// @brief Executes a new process from a function. kernel code only.
+/// @param main the start of the process.
+/// @return
+bool execute_from_image(MainKind main, const char* processName) noexcept {
+  if (!main) return false;
+
+  ProcessHeader proc((VoidPtr)main);
+  proc.Kind = ProcessHeader::kDriverKind;
+  rt_copy_memory((VoidPtr)processName, proc.Name, rt_string_len(proc.Name));
+
+  Ref<ProcessHeader> refProc = proc;
+
+  return ProcessScheduler::Shared().Leak().Add(refProc);
+}
\ No newline at end of file
diff --git a/Private/Source/KernelCheck.cxx b/Private/Source/KernelCheck.cxx
index d290ca3d..2c5431e8 100644
--- a/Private/Source/KernelCheck.cxx
+++ b/Private/Source/KernelCheck.cxx
@@ -91,8 +91,8 @@ void ke_stop(const NewOS::Int &id) {
 void ke_runtime_check(bool expr, const char *file, const char *line) {
   if (!expr) {
 #ifdef __DEBUG__
-    kcout << "NewKernel: File: " << file << "\n";
-    kcout << "NewKernel: Line: " << line << "\n";
+    kcout << "NewKernel: File: " << file << "\r\n";
+    kcout << "NewKernel: Line: " << line << "\r\n";
 
 #endif  // __DEBUG__
 
diff --git a/Private/Source/KernelHeap.cxx b/Private/Source/KernelHeap.cxx
index cdeabb24..10991b36 100644
--- a/Private/Source/KernelHeap.cxx
+++ b/Private/Source/KernelHeap.cxx
@@ -13,7 +13,8 @@
 //! @file KernelHeap.cxx
 //! @brief Kernel allocator.
 
-#define kHeapMagic 0xD4D7
+#define kHeapMagic (0xD4D7D5)
+#define kHeapHeaderPaddingSz (16U)
 
 namespace NewOS {
 STATIC SizeT kHeapCount = 0UL;
@@ -24,11 +25,12 @@ namespace Detail {
 /// Located before the address bytes.
 /// | HIB |  ADDRESS  |
 struct PACKED HeapInformationBlock final {
-  UInt16 hMagic;
-  Boolean hPresent;
-  Int32 hCRC32;
-  Int64 hSizeAddress;
-  UIntPtr hAddress;
+  UInt32    hMagic;
+  Boolean   hPresent;
+  UInt32    hCRC32;
+  SizeT     hSizeAddress;
+  UIntPtr   hTargetAddress;
+  UInt8     hPadding[kHeapHeaderPaddingSz];
 };
 
 typedef HeapInformationBlock *HeapInformationBlockPtr;
@@ -51,7 +53,7 @@ VoidPtr ke_new_ke_heap(SizeT sz, const bool rw, const bool user) {
   heapInfo->hSizeAddress = sz;
   heapInfo->hMagic = kHeapMagic;
   heapInfo->hCRC32 = 0;  // dont fill it for now.
-  heapInfo->hAddress = wrapper.VirtualAddress();
+  heapInfo->hTargetAddress = wrapper.VirtualAddress();
 
   ++kHeapCount;
 
@@ -70,11 +72,13 @@ Int32 ke_delete_ke_heap(VoidPtr heapPtr) {
           (UIntPtr)heapPtr - sizeof(Detail::HeapInformationBlock));
 
   if (virtualAddress && virtualAddress->hMagic == kHeapMagic) {
-    MUST_PASS(virtualAddress->hPresent);
+    if (!virtualAddress->hPresent) {
+      return -kErrorHeapNotPresent;
+    }
 
     if (virtualAddress->hCRC32 != 0) {
       if (virtualAddress->hCRC32 !=
-          ke_calculate_crc32((Char *)virtualAddress->hAddress,
+          ke_calculate_crc32((Char *)virtualAddress->hTargetAddress,
                              virtualAddress->hSizeAddress)) {
         ke_stop(RUNTIME_CHECK_POINTER);
       }
@@ -82,7 +86,7 @@ Int32 ke_delete_ke_heap(VoidPtr heapPtr) {
 
     virtualAddress->hSizeAddress = 0UL;
     virtualAddress->hPresent = false;
-    virtualAddress->hAddress = 0;
+    virtualAddress->hTargetAddress = 0;
     virtualAddress->hCRC32 = 0;
     virtualAddress->hMagic = 0;
 
diff --git a/Private/Source/PEFCodeManager.cxx b/Private/Source/PEFCodeManager.cxx
index 0ac703a3..ed247963 100644
--- a/Private/Source/PEFCodeManager.cxx
+++ b/Private/Source/PEFCodeManager.cxx
@@ -30,6 +30,8 @@ UInt32 rt_get_pef_platform(void) noexcept {
 }
 }  // namespace Detail
 
+/// @brief PEF loader constructor w/ blob.
+/// @param blob 
 PEFLoader::PEFLoader(const VoidPtr blob) : fCachedBlob(nullptr) {
   fCachedBlob = blob;
   fBad = false;
@@ -37,6 +39,8 @@ PEFLoader::PEFLoader(const VoidPtr blob) : fCachedBlob(nullptr) {
   MUST_PASS(fCachedBlob);
 }
 
+/// @brief PEF loader constructor.
+/// @param path 
 PEFLoader::PEFLoader(const char *path) : fCachedBlob(nullptr), fBad(false) {
   OwnPtr<FileStream<char>> file;
 
@@ -73,6 +77,7 @@ PEFLoader::PEFLoader(const char *path) : fCachedBlob(nullptr), fBad(false) {
   }
 }
 
+/// @brief PEF destructor.
 PEFLoader::~PEFLoader() {
   if (fCachedBlob) ke_delete_ke_heap(fCachedBlob);
 }
@@ -89,11 +94,11 @@ VoidPtr PEFLoader::FindSymbol(const char *name, Int32 kind) {
 
   switch (kind) {
     case kPefCode: {
-      errOrSym = StringBuilder::Construct(".text$");
+      errOrSym = StringBuilder::Construct(".code64$");
       break;
     }
     case kPefData: {
-      errOrSym = StringBuilder::Construct(".data$");
+      errOrSym = StringBuilder::Construct(".data64$");
       break;
     }
     case kPefZero: {
@@ -126,6 +131,8 @@ VoidPtr PEFLoader::FindSymbol(const char *name, Int32 kind) {
   return nullptr;
 }
 
+/// @brief Finds the executable entrypoint.
+/// @return 
 ErrorOr<VoidPtr> PEFLoader::FindStart() {
   if (auto sym = this->FindSymbol(kPefStart, kPefCode); sym)
     return ErrorOr<VoidPtr>(sym);
@@ -133,8 +140,12 @@ ErrorOr<VoidPtr> PEFLoader::FindStart() {
   return ErrorOr<VoidPtr>(H_EXEC_ERROR);
 }
 
+/// @brief Tells if the executable is loaded or not.
+/// @return 
 bool PEFLoader::IsLoaded() noexcept { return !fBad && fCachedBlob; }
 
+#define kPefAppnameCommandHdr "PefAppName"
+
 namespace Utils {
 bool execute_from_image(PEFLoader &exec) noexcept {
   auto errOrStart = exec.FindStart();
@@ -144,6 +155,9 @@ bool execute_from_image(PEFLoader &exec) noexcept {
   ProcessHeader proc(errOrStart.Leak().Leak());
   Ref<ProcessHeader> refProc = proc;
 
+  proc.Kind = ProcessHeader::kUserKind;
+  rt_copy_memory(exec.FindSymbol(kPefAppnameCommandHdr, kPefData), proc.Name, rt_string_len((const Char*)exec.FindSymbol(kPefAppnameCommandHdr, kPefData)));
+
   return ProcessScheduler::Shared().Leak().Add(refProc);
 }
 }  // namespace Utils
diff --git a/Private/Source/ProcessScheduler.cxx b/Private/Source/ProcessScheduler.cxx
index c29b4c89..88e0e074 100644
--- a/Private/Source/ProcessScheduler.cxx
+++ b/Private/Source/ProcessScheduler.cxx
@@ -146,6 +146,7 @@ void ProcessHeader::Exit(Int32 exit_code) {
 
 SizeT ProcessScheduler::Add(Ref<ProcessHeader> &process) {
   if (!process) return -1;
+  if (!mTeam.AsArray().Count() > kSchedProcessLimitPerTeam) return -kErrorOutOfTeamSlot;
 
   if (process.Leak().Ring != (Int32)ProcessSelector::kRingKernel) return -1;
 
@@ -237,7 +238,7 @@ bool ProcessHelper::CanBeScheduled(Ref<ProcessHeader> &process) {
     return false;
 
   if (process.Leak().GetStatus() == ProcessStatus::kStarting) {
-    if (process.Leak().PTime < static_cast<Int>(kMinMicroTime)) {
+    if (process.Leak().PTime < static_cast<Int>(kSchedMinMicroTime)) {
       process.Leak().Status = ProcessStatus::kRunning;
       process.Leak().Affinity = AffinityKind::kHartStandard;
 
@@ -247,7 +248,7 @@ bool ProcessHelper::CanBeScheduled(Ref<ProcessHeader> &process) {
     ++process.Leak().PTime;
   }
 
-  return process.Leak().PTime > static_cast<Int>(kMinMicroTime);
+  return process.Leak().PTime > static_cast<Int>(kSchedMinMicroTime);
 }
 
 /**
diff --git a/Private/Source/RuntimeMain.cxx b/Private/Source/RuntimeMain.cxx
index 3ae1d428..5bbee3b2 100644
--- a/Private/Source/RuntimeMain.cxx
+++ b/Private/Source/RuntimeMain.cxx
@@ -25,6 +25,8 @@ EXTERN_C void RuntimeMain(void) {
 
   NewOS::FilesystemManagerInterface::Mount(newFS);
   
+  while (NewOS::ProcessScheduler::Shared().Leak().Run() > 0);
+
   ///! we're done, unmount.
   delete newFS;
 }
\ No newline at end of file
diff --git a/Private/Source/UserHeap.cxx b/Private/Source/UserHeap.cxx
index dbec5728..1747b3fa 100644
--- a/Private/Source/UserHeap.cxx
+++ b/Private/Source/UserHeap.cxx
@@ -8,7 +8,7 @@
 #include <KernelKit/UserHeap.hpp>
 #include <KernelKit/ProcessScheduler.hpp>
 
-#define kHeapHeaderPaddingSz 16
+#define kHeapHeaderPaddingSz (16U)
 
 /// @file UserHeap.cxx
 /// @brief User Heap Manager, Process heap allocator.
@@ -38,7 +38,7 @@ class HeapManager final {
   STATIC SizeT& Count() { return s_NumPools; }
   STATIC Ref<Pmm>& Leak() { return s_Pmm; }
   STATIC Boolean& IsEnabled() { return s_PoolsAreEnabled; }
-  STATIC Array<Ref<PTEWrapper>, kUserHeapMaxSz>& The() { return s_Pool; }
+  STATIC MutableArray<Ref<PTEWrapper>>& The() { return s_Pool; }
 
  private:
   STATIC Size s_NumPools;
@@ -46,7 +46,7 @@ class HeapManager final {
 
  private:
   STATIC Boolean s_PoolsAreEnabled;
-  STATIC Array<Ref<PTEWrapper>, kUserHeapMaxSz> s_Pool;
+  STATIC MutableArray<Ref<PTEWrapper>> s_Pool;
 };
 
 //! declare fields
@@ -54,7 +54,7 @@ class HeapManager final {
 SizeT HeapManager::s_NumPools = 0UL;
 Ref<Pmm> HeapManager::s_Pmm;
 Boolean HeapManager::s_PoolsAreEnabled = true;
-Array<Ref<PTEWrapper>, kUserHeapMaxSz> HeapManager::s_Pool;
+MutableArray<Ref<PTEWrapper>> HeapManager::s_Pool;
 
 STATIC VoidPtr ke_find_unused_heap(Int flags);
 STATIC Void ke_free_heap_internal(VoidPtr vaddr);
@@ -67,7 +67,7 @@ STATIC Boolean ke_check_and_free_heap(const SizeT& index, VoidPtr ptr);
 STATIC VoidPtr ke_find_unused_heap(Int flags) {
   for (SizeT index = 0; index < kUserHeapMaxSz; ++index) {
     if (HeapManager::The()[index] &&
-        !HeapManager::The()[index].Leak().Leak().Leak().Present()) {
+        !HeapManager::The()[index].Leak().Leak().Present()) {
       HeapManager::Leak().Leak().TogglePresent(
           HeapManager::The()[index].Leak().Leak(), true);
       kcout << "[ke_find_unused_heap] Done, trying to make a pool now...\r\n";
@@ -75,7 +75,6 @@ STATIC VoidPtr ke_find_unused_heap(Int flags) {
       return ke_make_heap((VoidPtr)HeapManager::The()[index]
                               .Leak()
                               .Leak()
-                              .Leak()
                               .VirtualAddress(),
                           flags);
     }
@@ -143,7 +142,7 @@ STATIC Boolean ke_check_and_free_heap(const SizeT& index, VoidPtr ptr) {
     // ErrorOr<>::operator Boolean
     /// if (address matches)
     ///     -> Free heap.
-    if (HeapManager::The()[index].Leak().Leak().Leak().VirtualAddress() ==
+    if (HeapManager::The()[index].Leak().Leak().VirtualAddress() ==
         (UIntPtr)ptr) {
       HeapManager::Leak().Leak().FreePage(
           HeapManager::The()[index].Leak().Leak());