feat(sched_desgin): better architecture for the HTS.

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

8 files changed, 45 insertions, 60 deletions

diff --git a/dev/boot/src/HEL/AMD64/BootEFI.cc b/dev/boot/src/HEL/AMD64/BootEFI.cc
index dbc12265..12a912e5 100644
--- a/dev/boot/src/HEL/AMD64/BootEFI.cc
+++ b/dev/boot/src/HEL/AMD64/BootEFI.cc
@@ -243,7 +243,7 @@ EFI_EXTERN_C EFI_API Int32 BootloaderMain(EfiHandlePtr image_handle, EfiSystemTa
     handover_hdr->f_KernelImage = reader_kernel.Blob();
     handover_hdr->f_KernelSz    = reader_kernel.Size();
 
-    kernel_thread.Start(handover_hdr, YES);
+    kernel_thread.Start(handover_hdr, NO);
   }
 
   Boot::BootFileReader reader_netboot(L"net.efi", image_handle);
diff --git a/dev/kernel/HALKit/AMD64/HalApplicationProcessor.cc b/dev/kernel/HALKit/AMD64/HalApplicationProcessor.cc
index 89fe00b5..b12dc7fe 100644
--- a/dev/kernel/HALKit/AMD64/HalApplicationProcessor.cc
+++ b/dev/kernel/HALKit/AMD64/HalApplicationProcessor.cc
@@ -44,6 +44,8 @@
 ///////////////////////////////////////////////////////////////////////////////////////
 
 namespace Kernel::HAL {
+EXTERN_C Void sched_jump_to_task(HAL::StackFramePtr stack_frame);
+
 struct HAL_APIC_MADT;
 struct HAL_HARDWARE_THREAD;
 
@@ -59,9 +61,9 @@ STATIC Int64          kSMPCount  = 0;
 
 EXTERN_C UIntPtr kApicBaseAddress;
 
-STATIC Int32   kSMPInterrupt                           = 0;
-STATIC UInt64  kAPICLocales[kSchedProcessLimitPerTeam] = {0};
-STATIC VoidPtr kRawMADT                                = nullptr;
+STATIC Int32   kSMPInterrupt                   = 0;
+STATIC UInt64  kAPICLocales[kMaxAPInsideSched] = {0};
+STATIC VoidPtr kRawMADT                        = nullptr;
 
 /// @brief Multiple APIC Descriptor Table.
 struct HAL_APIC_MADT final SDT_OBJECT {
@@ -105,17 +107,11 @@ EXTERN_C HAL::StackFramePtr mp_get_current_context(Int64 pid) {
 }
 
 EXTERN_C BOOL mp_register_process(HAL::StackFramePtr stack_frame, ProcessID pid) {
-  MUST_PASS(stack_frame);
-
-  const auto process_index = pid % kSchedProcessLimitPerTeam;
-
-  kHWThread[process_index].mFramePtr  = stack_frame;
-  kHWThread[process_index].mProcessID = pid;
-
-  kHWThread[process_index].mCoreID = kAPICLocales[0];
+  if (pid > kSMPCount) return NO;
 
   if (mp_is_smp()) {
-    /// TODO:
+    kHWThread[pid].mFramePtr  = stack_frame;
+    kHWThread[pid].mProcessID = pid;
 
     return YES;
   }
diff --git a/dev/kernel/HALKit/AMD64/HalKernelMain.cc b/dev/kernel/HALKit/AMD64/HalKernelMain.cc
index f4585835..6020da3b 100644
--- a/dev/kernel/HALKit/AMD64/HalKernelMain.cc
+++ b/dev/kernel/HALKit/AMD64/HalKernelMain.cc
@@ -104,28 +104,34 @@ EXTERN_C Int32 hal_init_platform(Kernel::HEL::BootInfoHeader* handover_hdr) {
 }
 
 EXTERN_C Kernel::Void hal_real_init(Kernel::Void) noexcept {
-  Kernel::rtl_create_user_process(sched_idle_task, "MgmtSrv");    //! Mgmt command server.
-  Kernel::rtl_create_user_process(sched_idle_task, "LaunchSrv");  //! launchd
-  Kernel::rtl_create_user_process(sched_idle_task, "SecSrv");     //! Login Server
+  using namespace Kernel;
 
-  Kernel::HAL::mp_init_cores(kHandoverHeader->f_HardwareTables.f_VendorPtr);
+  for (SizeT index = 0UL; index < HardwareThreadScheduler::The().Capacity(); ++index) {
+    HardwareThreadScheduler::The()[index].Leak()->Kind() = ThreadKind::kAPStandard;
+  }
+
+  rtl_create_user_process(sched_idle_task, "MgmtSrv");    //! Mgmt command server.
+  rtl_create_user_process(sched_idle_task, "LaunchSrv");  //! launchd
+  rtl_create_user_process(sched_idle_task, "SecSrv");     //! Login Server
+
+  HAL::mp_init_cores(kHandoverHeader->f_HardwareTables.f_VendorPtr);
 
 #ifdef __FSKIT_INCLUDES_HEFS__
-  if (Kernel::HeFS::fs_init_hefs()) {
+  if (HeFS::fs_init_hefs()) {
     goto hal_spin_kernel;
   }
 #endif
 
-  if (!Kernel::NeFS::fs_init_nefs()) {
+  if (!NeFS::fs_init_nefs()) {
     kout << "NeFS cannot be formated on the disk. Aborting\r";
     dbg_break_point();
   }
 
 hal_spin_kernel:
-  Kernel::HAL::Register64 idt_reg;
-  idt_reg.Base = reinterpret_cast<Kernel::UIntPtr>(kInterruptVectorTable);
+  HAL::Register64 idt_reg;
+  idt_reg.Base = reinterpret_cast<UIntPtr>(kInterruptVectorTable);
 
-  Kernel::HAL::IDTLoader idt_loader;
+  HAL::IDTLoader idt_loader;
 
   idt_loader.Load(idt_reg);
 
diff --git a/dev/kernel/HALKit/AMD64/Storage/AHCI+Generic.cc b/dev/kernel/HALKit/AMD64/Storage/AHCI+Generic.cc
index 57e77e77..246c2e02 100644
--- a/dev/kernel/HALKit/AMD64/Storage/AHCI+Generic.cc
+++ b/dev/kernel/HALKit/AMD64/Storage/AHCI+Generic.cc
@@ -54,7 +54,6 @@
 
 using namespace Kernel;
 
-STATIC HardwareTimer kSATATimer(rtl_milliseconds(5));
 STATIC PCI::Device kSATADev;
 STATIC HbaMemRef   kSATAHba;
 STATIC Lba         kSATASectorCount                                        = 0UL;
diff --git a/dev/kernel/KernelKit/HardwareThreadScheduler.h b/dev/kernel/KernelKit/HardwareThreadScheduler.h
index 4a3220bd..11347c7e 100644
--- a/dev/kernel/KernelKit/HardwareThreadScheduler.h
+++ b/dev/kernel/KernelKit/HardwareThreadScheduler.h
@@ -23,7 +23,7 @@ class HardwareThreadScheduler;
 using ThreadID = UInt32;
 
 enum ThreadKind {
-  kAPInvalid,
+  kAPInvalid        = 0,
   kAPSystemReserved = 100,  // System reserved thread, well user can't use it
   kAPStandard,              // user thread, cannot be used by Kernel
   kAPRealTime,              // fallback thread, cannot be used by user if not clear or
@@ -58,7 +58,7 @@ class HardwareThread final {
   void Busy(const BOOL busy = false) noexcept;
 
  public:
-  BOOL Switch(HAL::StackFramePtr frame, const ThreadID& pid);
+  BOOL Switch(HAL::StackFramePtr frame);
   BOOL IsWakeup() noexcept;
 
  public:
diff --git a/dev/kernel/src/ACPIFactoryInterface.cc b/dev/kernel/src/ACPIFactoryInterface.cc
index ded49587..47a81f38 100644
--- a/dev/kernel/src/ACPIFactoryInterface.cc
+++ b/dev/kernel/src/ACPIFactoryInterface.cc
@@ -10,16 +10,18 @@
 #include <modules/ACPI/ACPIFactoryInterface.h>
 
 namespace Kernel {
+constexpr STATIC const auto kMinACPIVer = 1;
+
 /// @brief Finds a descriptor table inside ACPI XSDT.
 ErrorOr<voidPtr> ACPIFactoryInterface::Find(const Char* signature) {
   MUST_PASS(this->fRsdp);
 
-  if (!signature) return ErrorOr<voidPtr>{nullptr};
-  if (*signature == 0) return ErrorOr<voidPtr>{nullptr};
+  if (!signature) return ErrorOr<voidPtr>{-kErrorInvalidData};
+  if (*signature == 0) return ErrorOr<voidPtr>{-kErrorInvalidData};
 
   RSDP* rsp_ptr = reinterpret_cast<RSDP*>(this->fRsdp);
 
-  if (rsp_ptr->Revision < 1) return ErrorOr<voidPtr>{nullptr};
+  if (rsp_ptr->Revision < kMinACPIVer) return ErrorOr<voidPtr>{-kErrorInvalidData};
 
   RSDT* xsdt = reinterpret_cast<RSDT*>(rsp_ptr->RsdtAddress);
 
diff --git a/dev/kernel/src/HardwareThreadScheduler.cc b/dev/kernel/src/HardwareThreadScheduler.cc
index eda68104..09c1c7d8 100644
--- a/dev/kernel/src/HardwareThreadScheduler.cc
+++ b/dev/kernel/src/HardwareThreadScheduler.cc
@@ -104,16 +104,13 @@ Void HardwareThread::Wake(const bool wakeup) noexcept {
 /// @retval true stack was changed, code is running.
 /// @retval false stack is invalid, previous code is running.
 /***********************************************************************************/
-Bool HardwareThread::Switch(HAL::StackFramePtr frame, const ThreadID& pid) {
+Bool HardwareThread::Switch(HAL::StackFramePtr frame) {
   if (this->IsBusy()) return NO;
 
   this->fStack = frame;
-  this->fPID   = pid;
 
   Bool ret = mp_register_process(fStack, this->fPID);
 
-  if (ret) this->Busy(YES);
-
   return ret;
 }
 
@@ -159,10 +156,12 @@ HAL::StackFramePtr HardwareThreadScheduler::Leak() noexcept {
 /***********************************************************************************/
 Ref<HardwareThread*> HardwareThreadScheduler::operator[](SizeT idx) {
   if (idx >= kMaxAPInsideSched) {
-    STATIC HardwareThread* kFakeThread = nullptr;
+    HardwareThread* kFakeThread = nullptr;
     return {kFakeThread};
   }
 
+  fThreadList[idx].fPID = idx;
+
   return &fThreadList[idx];
 }
 
diff --git a/dev/kernel/src/UserProcessScheduler.cc b/dev/kernel/src/UserProcessScheduler.cc
index 165cfb5d..393f1419 100644
--- a/dev/kernel/src/UserProcessScheduler.cc
+++ b/dev/kernel/src/UserProcessScheduler.cc
@@ -25,8 +25,6 @@
 ///! BUGS: 0
 
 namespace Kernel {
-EXTERN_C Void sched_jump_to_task(HAL::StackFramePtr stack_frame);
-
 /***********************************************************************************/
 /// @brief Exit Code global variable.
 /***********************************************************************************/
@@ -598,41 +596,24 @@ SizeT UserProcessHelper::StartScheduling() {
 /***********************************************************************************/
 
 Bool UserProcessHelper::Switch(HAL::StackFramePtr frame_ptr, PID new_pid) {
+  (Void)(kout << "IP: " << hex_number(frame_ptr->IP) << kendl);
+
   for (SizeT index = 0UL; index < HardwareThreadScheduler::The().Capacity(); ++index) {
+    if (!HardwareThreadScheduler::The()[index].Leak()) continue;
+
     if (HardwareThreadScheduler::The()[index].Leak()->Kind() == kAPInvalid ||
         HardwareThreadScheduler::The()[index].Leak()->Kind() == kAPBoot)
       continue;
 
-    // A fallback is a special core for real-time tasks which needs immediate execution.
-    if (HardwareThreadScheduler::The()[index].Leak()->Kind() == kAPRealTime) {
-      if (UserProcessScheduler::The().TheCurrentTeam().AsArray()[new_pid].Affinity !=
-          AffinityKind::kRealTime)
-        continue;
-
-      if (HardwareThreadScheduler::The()[index].Leak()->Switch(frame_ptr, new_pid)) {
-        HardwareThreadScheduler::The()[index].Leak()->fPTime =
-            UserProcessScheduler::The().TheCurrentTeam().AsArray()[new_pid].PTime;
-
-        UserProcessHelper::TheCurrentPID().Leak().Leak() = UserProcessHelper::TheCurrentPID();
-
-        UserProcessScheduler::The().TheCurrentProcess() =
-            UserProcessScheduler::The().TheCurrentTeam().AsArray()[new_pid];
-
-        return YES;
-      }
-
-      continue;
-    }
-
-    if (UserProcessScheduler::The().TheCurrentTeam().AsArray()[new_pid].Affinity ==
-        AffinityKind::kRealTime)
-      continue;
+    (Void)(kout << "AP_" << hex_number(index) << kendl);
 
     ////////////////////////////////////////////////////////////
     ///	Prepare task switch.								 ///
     ////////////////////////////////////////////////////////////
 
-    Bool ret = HardwareThreadScheduler::The()[index].Leak()->Switch(frame_ptr, new_pid);
+    HardwareThreadScheduler::The()[index].Leak()->Busy(YES);
+    Bool ret = HardwareThreadScheduler::The()[index].Leak()->Switch(frame_ptr);
+    HardwareThreadScheduler::The()[index].Leak()->Busy(NO);
 
     ////////////////////////////////////////////////////////////
     ///	Rollback on fail.    								 ///
@@ -652,6 +633,8 @@ Bool UserProcessHelper::Switch(HAL::StackFramePtr frame_ptr, PID new_pid) {
     return YES;
   }
 
+  kout << "Couldn't find a suitable core for the current process!\r";
+
   return NO;
 }