dev(sched): Improvements and work in progress fixes.

what?

 - The main algorithm got improved for real time tasks, and SMP usage.
	- The SMP usage was present before, I just reintroduced it after
	realizing that it won't scale well from what I have right now.
 - Also removed weird implementations quirks from previous sketch.
	- Such as the core 0 being reserved for the boot core.
 - Also moved FS init code after IDT initalization.
	- To avoid weird FS format behavior.
 - Wrap HPET signature in a macro.

next?

 - Work on the HAL's userspace transition mechanism.

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

3 files changed, 22 insertions, 31 deletions

diff --git a/dev/kernel/src/ACPIFactoryInterface.cc b/dev/kernel/src/ACPIFactoryInterface.cc
index a76caff2..ded49587 100644
--- a/dev/kernel/src/ACPIFactoryInterface.cc
+++ b/dev/kernel/src/ACPIFactoryInterface.cc
@@ -14,13 +14,12 @@ namespace Kernel {
 ErrorOr<voidPtr> ACPIFactoryInterface::Find(const Char* signature) {
   MUST_PASS(this->fRsdp);
 
-  if (!signature) return ErrorOr<voidPtr>{-1};
-
-  if (*signature == 0) return ErrorOr<voidPtr>{-1};
+  if (!signature) return ErrorOr<voidPtr>{nullptr};
+  if (*signature == 0) return ErrorOr<voidPtr>{nullptr};
 
   RSDP* rsp_ptr = reinterpret_cast<RSDP*>(this->fRsdp);
 
-  if (rsp_ptr->Revision <= 1) return ErrorOr<voidPtr>{-1};
+  if (rsp_ptr->Revision < 1) return ErrorOr<voidPtr>{nullptr};
 
   RSDT* xsdt = reinterpret_cast<RSDT*>(rsp_ptr->RsdtAddress);
 
diff --git a/dev/kernel/src/HardwareThreadScheduler.cc b/dev/kernel/src/HardwareThreadScheduler.cc
index 6cb83b3d..eda68104 100644
--- a/dev/kernel/src/HardwareThreadScheduler.cc
+++ b/dev/kernel/src/HardwareThreadScheduler.cc
@@ -158,12 +158,8 @@ HAL::StackFramePtr HardwareThreadScheduler::Leak() noexcept {
  */
 /***********************************************************************************/
 Ref<HardwareThread*> HardwareThreadScheduler::operator[](SizeT idx) {
-  if (idx == 0) {
-    if (fThreadList[idx].Kind() != kAPSystemReserved) {
-      fThreadList[idx].fKind = kAPBoot;
-    }
-  } else if (idx >= kMaxAPInsideSched) {
-    static HardwareThread* kFakeThread = nullptr;
+  if (idx >= kMaxAPInsideSched) {
+    STATIC HardwareThread* kFakeThread = nullptr;
     return {kFakeThread};
   }
 
diff --git a/dev/kernel/src/UserProcessScheduler.cc b/dev/kernel/src/UserProcessScheduler.cc
index b0d56c5d..165cfb5d 100644
--- a/dev/kernel/src/UserProcessScheduler.cc
+++ b/dev/kernel/src/UserProcessScheduler.cc
@@ -494,37 +494,28 @@ SizeT UserProcessScheduler::Run() noexcept {
 
     //! Check if the process needs to be run.
     if (UserProcessHelper::CanBeScheduled(process)) {
-      if (process.StackSize > kSchedMaxStackSz) {
-        kout << "Process: " << process.Name << ", has not a valid stack size! Crashing it...\r";
-        process.Crash();
-        continue;
-      }
-
       kout << ((*process.Name) ? process.Name : "USER_PROCESS") << " will be scheduled...\r";
 
       process.PTime = static_cast<Int32>(process.Affinity);
 
-      if (process.PTime < process.RTime) {
+      if (process.PTime < process.RTime && AffinityKind::kRealTime != process.Affinity) {
         if (process.RTime < (Int32) AffinityKind::kVeryHigh)
-          process.RTime = (Int32) AffinityKind::kLowUsage;
+          process.RTime = (Int32) AffinityKind::kLowUsage / 2;
         else if (process.RTime < (Int32) AffinityKind::kHigh)
-          process.RTime = (Int32) AffinityKind::kStandard;
+          process.RTime = (Int32) AffinityKind::kStandard / 3;
         else if (process.RTime < (Int32) AffinityKind::kStandard)
-          process.RTime = (Int32) AffinityKind::kHigh;
+          process.RTime = (Int32) AffinityKind::kHigh / 4;
 
-        process.PTime += process.RTime;
+        process.PTime -= process.RTime;
         process.RTime = 0UL;
       }
 
       if (!UserProcessHelper::Switch(process.StackFrame, process.ProcessId)) {
-        break;
+        continue;
       }
-
-      mTeam.AsArray()[this->TheCurrentProcess().Leak().ProcessId] =
-          this->TheCurrentProcess().Leak();
-
-      this->TheCurrentProcess() = process;
     } else {
+      kout << ((*process.Name) ? process.Name : "USER_PROCESS") << " will be scheduled later...\r";
+
       ++process.RTime;
       --process.PTime;
     }
@@ -575,14 +566,13 @@ ErrorOr<PID> UserProcessHelper::TheCurrentPID() {
 /// @retval false cannot be schedulded.
 Bool UserProcessHelper::CanBeScheduled(const USER_PROCESS& process) {
   if (process.Status != ProcessStatusKind::kRunning) return No;
-
+  if (process.StackSize > kSchedMaxStackSz) return No;
   if (!process.Name[0]) return No;
 
   // real time processes shouldn't wait that much.
   if (process.Affinity == AffinityKind::kRealTime) return Yes;
 
-  if (process.Signal.SignalID == SIGKILL || process.Signal.SignalID == SIGABRT ||
-      process.Signal.SignalID == SIGTRAP) {
+  if (process.Signal.SignalID == SIGTRAP) {
     return No;
   }
 
@@ -625,7 +615,10 @@ Bool UserProcessHelper::Switch(HAL::StackFramePtr frame_ptr, PID new_pid) {
 
         UserProcessHelper::TheCurrentPID().Leak().Leak() = UserProcessHelper::TheCurrentPID();
 
-        break;
+        UserProcessScheduler::The().TheCurrentProcess() =
+            UserProcessScheduler::The().TheCurrentTeam().AsArray()[new_pid];
+
+        return YES;
       }
 
       continue;
@@ -653,6 +646,9 @@ Bool UserProcessHelper::Switch(HAL::StackFramePtr frame_ptr, PID new_pid) {
         UserProcessScheduler::The().TheCurrentTeam().AsArray()[new_pid].PTime;
     HardwareThreadScheduler::The()[index].Leak()->Wake(YES);
 
+    UserProcessScheduler::The().TheCurrentProcess() =
+        UserProcessScheduler::The().TheCurrentTeam().AsArray()[new_pid];
+
     return YES;
   }