Kernel and System.Core: kernel related fixes and :boom: on User API.

- UserHeap.cxx: Document code and fix issue in ke_free_heap_internal.
- Scheduler: Rename ProcessManager to ProcessScheduler.

- The System API has been reworked to improve it's design, such as no
  more C++ to improve it's portability.

- Moved containers into it's own API.

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

7 files changed, 45 insertions, 26 deletions

diff --git a/Private/Source/IndexableProperty.cxx b/Private/Source/IndexableProperty.cxx
index 4341038c..3d5152bf 100644
--- a/Private/Source/IndexableProperty.cxx
+++ b/Private/Source/IndexableProperty.cxx
@@ -11,6 +11,7 @@
 #include <NewKit/MutableArray.hpp>
 #include <NewKit/Utils.hpp>
 
+/// @brief File Indexer.
 /// BUGS: 0
 
 #define kMaxLenIndexer 256
diff --git a/Private/Source/PEFCodeManager.cxx b/Private/Source/PEFCodeManager.cxx
index ec8756d1..fc12d7a4 100644
--- a/Private/Source/PEFCodeManager.cxx
+++ b/Private/Source/PEFCodeManager.cxx
@@ -144,7 +144,7 @@ bool execute_from_image(PEFLoader &exec) noexcept {
   ProcessHeader proc(errOrStart.Leak().Leak());
   Ref<ProcessHeader> refProc = proc;
 
-  return ProcessManager::Shared().Leak().Add(refProc);
+  return ProcessScheduler::Shared().Leak().Add(refProc);
 }
 }  // namespace Utils
 
diff --git a/Private/Source/PEFSharedObjectRT.cxx b/Private/Source/PEFSharedObjectRT.cxx
index 06c5813c..dc75e8b6 100644
--- a/Private/Source/PEFSharedObjectRT.cxx
+++ b/Private/Source/PEFSharedObjectRT.cxx
@@ -39,7 +39,7 @@ EXTERN_C SharedObjectPtr rt_library_init(void) {
   SharedObjectPtr library = tls_new_class<SharedObject>();
 
   if (!library) {
-    ProcessManager::Shared().Leak().GetCurrent().Leak().Crash();
+    ProcessScheduler::Shared().Leak().GetCurrent().Leak().Crash();
 
     return nullptr;
   }
@@ -47,16 +47,16 @@ EXTERN_C SharedObjectPtr rt_library_init(void) {
   library->Mount(tls_new_class<SharedObject::SharedObjectTrait>());
 
   if (!library->Get()) {
-    ProcessManager::Shared().Leak().GetCurrent().Leak().Crash();
+    ProcessScheduler::Shared().Leak().GetCurrent().Leak().Crash();
 
     return nullptr;
   }
 
   library->Get()->fImageObject =
-      ProcessManager::Shared().Leak().GetCurrent().Leak().Image;
+      ProcessScheduler::Shared().Leak().GetCurrent().Leak().Image;
 
   if (!library->Get()->fImageObject) {
-    ProcessManager::Shared().Leak().GetCurrent().Leak().Crash();
+    ProcessScheduler::Shared().Leak().GetCurrent().Leak().Crash();
 
     return nullptr;
   }
@@ -79,7 +79,7 @@ EXTERN_C Void rt_library_free(SharedObjectPtr lib, bool *successful) {
   // sanity check (will also trigger a bug check)
   if (lib == nullptr) {
     *successful = false;
-    ProcessManager::Shared().Leak().GetCurrent().Leak().Crash();
+    ProcessScheduler::Shared().Leak().GetCurrent().Leak().Crash();
   }
 
   delete lib->Get();
diff --git a/Private/Source/ProcessScheduler.cxx b/Private/Source/ProcessScheduler.cxx
index a2c47225..ebcf82c0 100644
--- a/Private/Source/ProcessScheduler.cxx
+++ b/Private/Source/ProcessScheduler.cxx
@@ -5,7 +5,7 @@
 ------------------------------------------- */
 
 /***********************************************************************************/
-/// @file ProcessManager.cxx
+/// @file ProcessScheduler.cxx
 /// @brief ProcessHeader Scheduler API.
 /***********************************************************************************/
 
@@ -32,7 +32,7 @@ const Int32 &rt_get_exit_code() noexcept { return kExitCode; }
 /***********************************************************************************/
 
 void ProcessHeader::Crash() {
-  kcout << "ProcessManager: Crashed, ExitCode: -1.\r\n";
+  kcout << "ProcessScheduler: Crashed, ExitCode: -1.\r\n";
   MUST_PASS(!ke_bug_check());
 
   this->Exit(-1);
@@ -115,11 +115,11 @@ const AffinityKind &ProcessHeader::GetAffinity() { return this->Affinity; }
 */
 void ProcessHeader::Exit(Int32 exit_code) {
   if (this->ProcessId !=
-      ProcessManager::Shared().Leak().GetCurrent().Leak().ProcessId)
+      ProcessScheduler::Shared().Leak().GetCurrent().Leak().ProcessId)
     ke_stop(RUNTIME_CHECK_PROCESS);
 
   if (this->Ring == (Int32)ProcessSelector::kRingKernel &&
-      ProcessManager::Shared().Leak().GetCurrent().Leak().Ring > 0)
+      ProcessScheduler::Shared().Leak().GetCurrent().Leak().Ring > 0)
     ke_stop(RUNTIME_CHECK_PROCESS);
 
   kExitCode = exit_code;
@@ -141,15 +141,15 @@ void ProcessHeader::Exit(Int32 exit_code) {
   this->Image = nullptr;
   this->StackFrame = nullptr;
 
-  ProcessManager::Shared().Leak().Remove(this->ProcessId);
+  ProcessScheduler::Shared().Leak().Remove(this->ProcessId);
 }
 
-SizeT ProcessManager::Add(Ref<ProcessHeader> &process) {
+SizeT ProcessScheduler::Add(Ref<ProcessHeader> &process) {
   if (!process) return -1;
 
   if (process.Leak().Ring != (Int32)ProcessSelector::kRingKernel) return -1;
 
-  kcout << "ProcessManager::Add(Ref<ProcessHeader>& process)\r\n";
+  kcout << "ProcessScheduler::Add(Ref<ProcessHeader>& process)\r\n";
 
   process.Leak().HeapPtr = rt_new_heap(kUserHeapUser | kUserHeapRw);
   process.Leak().ProcessId = mTeam.AsArray().Count();
@@ -180,15 +180,15 @@ SizeT ProcessManager::Add(Ref<ProcessHeader> &process) {
   return mTeam.AsArray().Count() - 1;
 }
 
-bool ProcessManager::Remove(SizeT process) {
+bool ProcessScheduler::Remove(SizeT process) {
   if (process > mTeam.AsArray().Count()) return false;
 
-  kcout << "ProcessManager::Remove(SizeT process)\r\n";
+  kcout << "ProcessScheduler::Remove(SizeT process)\r\n";
 
   return mTeam.AsArray().Remove(process);
 }
 
-SizeT ProcessManager::Run() noexcept {
+SizeT ProcessScheduler::Run() noexcept {
   SizeT processIndex = 0;  //! we store this guy to tell the scheduler how many
                            //! things we have scheduled.
 
@@ -219,16 +219,16 @@ SizeT ProcessManager::Run() noexcept {
   return processIndex;
 }
 
-Ref<ProcessManager> ProcessManager::Shared() {
-  static ProcessManager ref;
+Ref<ProcessScheduler> ProcessScheduler::Shared() {
+  static ProcessScheduler ref;
   return {ref};
 }
 
-Ref<ProcessHeader> &ProcessManager::GetCurrent() { return mTeam.AsRef(); }
+Ref<ProcessHeader> &ProcessScheduler::GetCurrent() { return mTeam.AsRef(); }
 
 PID &ProcessHelper::GetCurrentPID() {
   kcout << "ProcessHelper::GetCurrentPID: Leaking ProcessId...\r\n";
-  return ProcessManager::Shared().Leak().GetCurrent().Leak().ProcessId;
+  return ProcessScheduler::Shared().Leak().GetCurrent().Leak().ProcessId;
 }
 
 bool ProcessHelper::CanBeScheduled(Ref<ProcessHeader> &process) {
@@ -255,12 +255,12 @@ bool ProcessHelper::CanBeScheduled(Ref<ProcessHeader> &process) {
  */
 bool ProcessHelper::StartScheduling() {
   if (ProcessHelper::CanBeScheduled(
-          ProcessManager::Shared().Leak().GetCurrent())) {
-    --ProcessManager::Shared().Leak().GetCurrent().Leak().PTime;
+          ProcessScheduler::Shared().Leak().GetCurrent())) {
+    --ProcessScheduler::Shared().Leak().GetCurrent().Leak().PTime;
     return false;
   }
 
-  auto processRef = ProcessManager::Shared().Leak();
+  auto processRef = ProcessScheduler::Shared().Leak();
 
   if (!processRef)
     return false;  // we have nothing to schedule. simply return.
diff --git a/Private/Source/ThreadLocalStorage.cxx b/Private/Source/ThreadLocalStorage.cxx
index 45a52e46..c75c1c5a 100644
--- a/Private/Source/ThreadLocalStorage.cxx
+++ b/Private/Source/ThreadLocalStorage.cxx
@@ -47,7 +47,7 @@ EXTERN_C Void tls_check_syscall_impl(HCore::HAL::StackFramePtr stackPtr) noexcep
 
   if (!tls_check_tib(tib)) {
     kcout << "NewKernel.exe: Verification failed, Crashing...\n";
-    ProcessManager::Shared().Leak().GetCurrent().Leak().Crash();
+    ProcessScheduler::Shared().Leak().GetCurrent().Leak().Crash();
   }
 
   kcout << "NewKernel.exe: Verification succeeded! Keeping on...\n";
diff --git a/Private/Source/Timer.cxx b/Private/Source/Timer.cxx
index ecca679a..af9aea25 100644
--- a/Private/Source/Timer.cxx
+++ b/Private/Source/Timer.cxx
@@ -10,8 +10,11 @@
 
 using namespace HCore;
 
+/// @brief Unimplemented as it is an interface.
 Int32 HardwareTimerInterface::Wait() noexcept { return H_UNIMPLEMENTED; }
 
+/// @brief HardwareTimer class, meant to be generic.
+
 HardwareTimer::HardwareTimer(Int64 seconds) : fWaitFor(seconds) {}
 HardwareTimer::~HardwareTimer() { fWaitFor = 0; }
 
diff --git a/Private/Source/UserHeap.cxx b/Private/Source/UserHeap.cxx
index 45b29d51..4b172d11 100644
--- a/Private/Source/UserHeap.cxx
+++ b/Private/Source/UserHeap.cxx
@@ -6,6 +6,7 @@
 
 #include <NewKit/PageManager.hpp>
 #include <KernelKit/UserHeap.hpp>
+#include <KernelKit/ProcessScheduler.hpp>
 
 #define kHeapHeaderPaddingSz 16
 
@@ -60,6 +61,9 @@ STATIC Void ke_free_heap_internal(VoidPtr vaddr);
 STATIC VoidPtr ke_make_heap(VoidPtr vaddr, Int flags);
 STATIC Boolean ke_check_and_free_heap(const SizeT& index, VoidPtr ptr);
 
+/// @brief Find an unused heap header to allocate on.
+/// @param flags the flags to use.
+/// @return 
 STATIC VoidPtr ke_find_unused_heap(Int flags) {
   for (SizeT index = 0; index < kUserHeapMaxSz; ++index) {
     if (HeapManager::The()[index] &&
@@ -80,6 +84,10 @@ STATIC VoidPtr ke_find_unused_heap(Int flags) {
   return nullptr;
 }
 
+/// @brief Makes a new heap for the process to use.
+/// @param virtualAddress the virtual address of the process.
+/// @param flags the flags.
+/// @return 
 STATIC VoidPtr ke_make_heap(VoidPtr virtualAddress, Int flags) {
   if (virtualAddress) {
     UserHeapHeader* poolHdr = reinterpret_cast<UserHeapHeader*>(virtualAddress);
@@ -102,14 +110,21 @@ STATIC VoidPtr ke_make_heap(VoidPtr virtualAddress, Int flags) {
   return nullptr;
 }
 
+/// @brief Internally makrs the heap as free.
+/// This is done by setting the fFree bit to true
+/// @param virtualAddress 
+/// @return 
 STATIC Void ke_free_heap_internal(VoidPtr virtualAddress) {
   UserHeapHeader* poolHdr = reinterpret_cast<UserHeapHeader*>(
       reinterpret_cast<UIntPtr>(virtualAddress) - sizeof(UserHeapHeader));
 
   if (poolHdr->fMagic == kUserHeapMag) {
-    MUST_PASS(poolHdr->fFree);
+    if (!poolHdr->fFree) {
+      ProcessScheduler::Shared().Leak().GetCurrent().Leak().Crash();
+      return;
+    }
 
-    poolHdr->fFree = false;
+    poolHdr->fFree = true;
     poolHdr->fFlags = 0;
 
     kcout << "[ke_free_heap_internal] Successfully marked header as free!\r\n";