HCR-18: Heap and scheduler improvements.

Signed-off-by: Amlal El Mahrouss <amlalelmahrouss@icloud.com>

4 files changed, 43 insertions, 18 deletions

diff --git a/Private/KernelKit/ProcessManager.hpp b/Private/KernelKit/ProcessManager.hpp
index e6d86959..543b3007 100644
--- a/Private/KernelKit/ProcessManager.hpp
+++ b/Private/KernelKit/ProcessManager.hpp
@@ -130,17 +130,25 @@ class Process final {
   ProcessStatus Status;
 
   // Memory, images.
-  HeapPtr PoolCursor{nullptr};
+  HeapPtr HeapCursor{nullptr};
   ImagePtr Image{nullptr};
-  HeapPtr Pool{nullptr};
+  HeapPtr HeapPtr{nullptr};
 
   // memory usage
   SizeT UsedMemory{0};
   SizeT FreeMemory{0};
 
+  enum {
+    ExecutableType,
+    DLLType,
+    DriverType,
+    TypeCount,
+  };
+
   ProcessTime PTime;
   PID ProcessId{-1};
   Int32 Ring{3};
+  Int32 Kind{0};
 
  public:
   //! @brief boolean operator, check status.
diff --git a/Private/NewKit/Macros.hpp b/Private/NewKit/Macros.hpp
index 739447b0..ecd2d678 100644
--- a/Private/NewKit/Macros.hpp
+++ b/Private/NewKit/Macros.hpp
@@ -89,3 +89,7 @@
 
 #define EXTERN extern
 #define STATIC static
+
+#ifndef self
+#define self this
+#endif
diff --git a/Private/Source/ProcessManager.cxx b/Private/Source/ProcessManager.cxx
index 07f73ef3..ccf037ae 100644
--- a/Private/Source/ProcessManager.cxx
+++ b/Private/Source/ProcessManager.cxx
@@ -18,6 +18,8 @@
 #include <NewKit/KernelHeap.hpp>
 #include <NewKit/String.hpp>
 
+#include "NewKit/RuntimeCheck.hpp"
+
 ///! bugs = 0
 
 /***********************************************************************************/
@@ -54,10 +56,9 @@ void Process::Wake(const bool should_wakeup) {
 VoidPtr Process::New(const SizeT &sz) {
   if (this->FreeMemory < 1) return nullptr;
 
-  // RAM allocation
-  if (this->PoolCursor) {
-    VoidPtr ptr = this->PoolCursor;
-    this->PoolCursor = (VoidPtr)((UIntPtr)this->PoolCursor + (sizeof(sz)));
+  if (this->HeapCursor) {
+    VoidPtr ptr = this->HeapCursor;
+    this->HeapCursor = (VoidPtr)((UIntPtr)this->HeapCursor + (sizeof(sz)));
 
     ++this->UsedMemory;
     --this->FreeMemory;
@@ -86,13 +87,13 @@ bool rt_in_pool_region(VoidPtr pool_ptr, VoidPtr pool, const SizeT &sz) {
 
 /* @brief free pointer from usage. */
 Boolean Process::Delete(VoidPtr ptr, const SizeT &sz) {
-  if (sz < 1 || this->PoolCursor == this->Pool) return false;
+  if (sz < 1 || this->HeapCursor == this->HeapPtr) return false;
 
   // also check for the amount of allocations we've done so far.
   if (this->UsedMemory < 1) return false;
 
-  if (rt_in_pool_region(ptr, this->PoolCursor, this->UsedMemory)) {
-    this->PoolCursor = (VoidPtr)((UIntPtr)this->PoolCursor - (sizeof(sz)));
+  if (rt_in_pool_region(ptr, this->HeapCursor, this->UsedMemory)) {
+    this->HeapCursor = (VoidPtr)((UIntPtr)this->HeapCursor - (sizeof(sz)));
     rt_zero_memory(ptr, sz);
 
     ++this->FreeMemory;
@@ -131,12 +132,11 @@ void Process::Exit(Int32 exit_code) {
 
   kExitCode = exit_code;
 
-  if (this->Ring != (Int32)ProcessSelector::kRingDriver &&
-      this->Ring != (Int32)ProcessSelector::kRingKernel) {
-    if (this->Pool) ke_free_heap(this->Pool);
+  if (this->Ring != (Int32)ProcessSelector::kRingDriver) {
+    if (this->HeapPtr) ke_free_heap(this->HeapPtr);
 
-    this->Pool = nullptr;
-    this->PoolCursor = nullptr;
+    this->HeapPtr = nullptr;
+    this->HeapCursor = nullptr;
 
     this->FreeMemory = 0UL;  // TODO: fill available heap.
     this->UsedMemory = 0UL;
@@ -155,11 +155,13 @@ void Process::Exit(Int32 exit_code) {
 bool ProcessManager::Add(Ref<Process> &process) {
   if (!process) return false;
 
+  if (process.Leak().Ring != (Int32)ProcessSelector::kRingKernel) return false;
+
   kcout << "ProcessManager::Add(Ref<Process>& process)\r\n";
 
-  process.Leak().Pool = ke_new_heap(kPoolUser | kPoolRw);
+  process.Leak().HeapPtr = ke_new_heap(kPoolUser | kPoolRw);
   process.Leak().ProcessId = this->m_Headers.Count();
-  process.Leak().PoolCursor = process.Leak().Pool;
+  process.Leak().HeapCursor = process.Leak().HeapPtr;
 
   process.Leak().StackFrame = reinterpret_cast<HAL::StackFrame *>(
       ke_new_ke_heap(sizeof(HAL::StackFrame), true, false));
@@ -172,6 +174,17 @@ bool ProcessManager::Add(Ref<Process> &process) {
 
   this->m_Headers.Add(process);
 
+  if (!imageStart && process.Leak().Kind == Process::ExecutableType) {
+    process.Leak().Crash();
+  }
+
+  if (!imageStart && process.Leak().Kind == Process::DriverType) {
+    if (process.Leak().Ring == 3)
+      process.Leak().Crash();
+    else
+      ke_stop(RUNTIME_CHECK_PROCESS);
+  }
+
   return true;
 }
 
diff --git a/Private/Source/UserHeap.cxx b/Private/Source/UserHeap.cxx
index 9b985ed4..d3d60f6b 100644
--- a/Private/Source/UserHeap.cxx
+++ b/Private/Source/UserHeap.cxx
@@ -75,7 +75,7 @@ STATIC VoidPtr ke_make_heap(VoidPtr virtualAddress, Int flags) {
     HeapHeader* poolHdr = reinterpret_cast<HeapHeader*>(virtualAddress);
 
     if (!poolHdr->Free) {
-      kcout << "[ke_make_heap] poolHdr->Free, Pool already exists\n";
+      kcout << "[ke_make_heap] poolHdr->Free, HeapPtr already exists\n";
       return nullptr;
     }
 
@@ -115,7 +115,7 @@ STATIC Boolean ke_check_and_free_heap(const SizeT& index, VoidPtr ptr) {
   if (HeapManager::The()[index]) {
     // ErrorOr<>::operator Boolean
     /// if (address matches)
-    ///     -> Free Pool.
+    ///     -> Free heap.
     if (HeapManager::The()[index].Leak().Leak().Leak()->VirtualAddress() ==
         (UIntPtr)ptr) {
       HeapManager::Leak().Leak().FreePage(