[FEAT] kernel! CPS breaking changes in macro names.

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

10 files changed, 45 insertions, 46 deletions

diff --git a/src/kernel/HALKit/AMD64/HalApplicationProcessor.cpp b/src/kernel/HALKit/AMD64/HalApplicationProcessor.cpp
index 2ff27ee2..6e9f273f 100644
--- a/src/kernel/HALKit/AMD64/HalApplicationProcessor.cpp
+++ b/src/kernel/HALKit/AMD64/HalApplicationProcessor.cpp
@@ -59,7 +59,7 @@ STATIC Int32   kSMPInterrupt                   = 0;
 STATIC UInt64  kAPICLocales[kMaxAPInsideSched] = {0};
 STATIC VoidPtr kRawMADT                        = nullptr;
 
-STATIC HAL_HARDWARE_THREAD kHWThread[kSchedProcessLimitPerTeam] = {{}};
+STATIC HAL_HARDWARE_THREAD kHWThread[kCPSProcessLimitPerTeam] = {{}};
 
 /// @brief Multiple APIC Descriptor Table.
 struct HAL_APIC_MADT final SDT_OBJECT {
diff --git a/src/kernel/KernelKit/CoreProcessScheduler.h b/src/kernel/KernelKit/CoreProcessScheduler.h
index 0d915f12..f517a374 100644
--- a/src/kernel/KernelKit/CoreProcessScheduler.h
+++ b/src/kernel/KernelKit/CoreProcessScheduler.h
@@ -13,15 +13,15 @@
 /// @brief Core Process Scheduler header file.
 /// @author Amlal El Mahrouss (amlal@nekernel.org)
 
-#define kSchedMinMicroTime (AffinityKind::kStandard)
-#define kSchedInvalidPID (-1)
-#define kSchedProcessLimitPerTeam (32U)
-#define kSchedTeamCount (256U)
+#define kCPSMinMicroTime (AffinityKind::kStandard)
+#define kCPSInvalidPID (-1)
+#define kCPSProcessLimitPerTeam (32U)
+#define kCPSTeamCount (256U)
 
-#define kSchedMaxMemoryLimit (gib_cast(128)) /* max physical memory limit */
-#define kSchedMaxStackSz (kib_cast(8))       /* maximum stack size */
+#define kCPSMaxMemoryLimit (gib_cast(128)) /* max physical memory limit */
+#define kCPSMaxStackSz (kib_cast(8))       /* maximum stack size */
 
-#define kSchedNameLen (128U)
+#define kCPSNameLen (128U)
 
 EXTERN_C void sched_idle_task(void);
 
diff --git a/src/kernel/KernelKit/KernelTask.h b/src/kernel/KernelKit/KernelTask.h
index 6e319cbe..8227f7d1 100644
--- a/src/kernel/KernelKit/KernelTask.h
+++ b/src/kernel/KernelKit/KernelTask.h
@@ -24,11 +24,11 @@ using KID = ProcessID;
 /// @author Amlal
 class KernelTask final {
  public:
-  Char               Name[kSchedNameLen] = {"KernelTask"};
+  Char               Name[kCPSNameLen] = {"KernelTask"};
   ProcessSubsystem   SubSystem{ProcessSubsystem::kProcessSubsystemKernel};
   HAL::StackFramePtr StackFrame{nullptr};
   UInt8*             StackReserve{nullptr};
-  SizeT              StackSize{kSchedMaxStackSz};
+  SizeT              StackSize{kCPSMaxStackSz};
   ProcessImage       Image{};
 
   /// @brief a KID is a Kernel ID, it is used to find a task running within the kernel.
diff --git a/src/kernel/KernelKit/UserProcessScheduler.h b/src/kernel/KernelKit/UserProcessScheduler.h
index 4a160121..b4fc1d99 100644
--- a/src/kernel/KernelKit/UserProcessScheduler.h
+++ b/src/kernel/KernelKit/UserProcessScheduler.h
@@ -52,17 +52,17 @@ class UserProcess final {
     UIntPtr           SignalID{0};
   };
 
-  Char               Name[kSchedNameLen] = {"UserProcess"};
+  Char               Name[kCPSNameLen] = {"UserProcess"};
   ProcessSubsystem   SubSystem{ProcessSubsystem::kProcessSubsystemUser};
   User*              Owner{nullptr};
   HAL::StackFramePtr StackFrame{nullptr};
   AffinityKind       Affinity{AffinityKind::kStandard};
   ProcessStatusKind  Status{ProcessStatusKind::kKilled};
-  UInt8              StackReserve[kSchedMaxStackSz];
-  SizeT              StackSize{kSchedMaxStackSz};
+  UInt8              StackReserve[kCPSMaxStackSz];
+  SizeT              StackSize{kCPSMaxStackSz};
   IDylibObject*      DylibDelegate{nullptr};
   SizeT              MemoryCursor{0UL};
-  SizeT              MemoryLimit{kSchedMaxMemoryLimit};
+  SizeT              MemoryLimit{kCPSMaxMemoryLimit};
   SizeT              UsedMemory{0UL};
   UserProcessSignal  Signal;
   ProcessImage       Image;
@@ -86,7 +86,7 @@ class UserProcess final {
   ProcessTime RTime{0};  //! @brief Process run time.
   ProcessTime UTime{0};  //! #brief Process used time.
 
-  ProcessID      ProcessId{kSchedInvalidPID};
+  ProcessID      ProcessId{kCPSInvalidPID};
   ExecutableKind Kind{ExecutableKind::kExecutableKind};
 
  public:
@@ -193,7 +193,7 @@ inline bool operator>=(UserProcess::ExecutableKind lhs, UserProcess::ExecutableK
   return lhs_int >= rhs_int;
 }
 
-using UserProcessArray = Array<UserProcess, kSchedProcessLimitPerTeam>;
+using UserProcessArray = Array<UserProcess, kCPSProcessLimitPerTeam>;
 using UserProcessRef   = Ref<UserProcess>;
 
 /// \brief Processs Team (contains multiple processes inside it.)
@@ -205,7 +205,7 @@ class UserProcessTeam final {
 
   NE_COPY_DEFAULT(UserProcessTeam)
 
-  Array<UserProcess, kSchedProcessLimitPerTeam>& AsArray();
+  Array<UserProcess, kCPSProcessLimitPerTeam>& AsArray();
   Ref<UserProcess>&                              AsRef();
   ProcessID&                                     Id();
 
diff --git a/src/kernel/src/CodeMgr.cpp b/src/kernel/src/CodeMgr.cpp
index b02c6c27..8344fefc 100644
--- a/src/kernel/src/CodeMgr.cpp
+++ b/src/kernel/src/CodeMgr.cpp
@@ -30,7 +30,7 @@ BOOL rtl_create_kernel_task(KernelTask& task, const KID& kid) {
 /***********************************************************************************/
 
 ProcessID rtl_create_user_process(rtl_start_kind main, const Char* process_name) {
-  if (!process_name || *process_name == 0) return kSchedInvalidPID;
+  if (!process_name || *process_name == 0) return kCPSInvalidPID;
   return UserProcessScheduler::The().Spawn(process_name, reinterpret_cast<VoidPtr>(main), nullptr);
 }
 
diff --git a/src/kernel/src/HardwareThreadScheduler.cpp b/src/kernel/src/HardwareThreadScheduler.cpp
index b6c93b1b..77b8d67d 100644
--- a/src/kernel/src/HardwareThreadScheduler.cpp
+++ b/src/kernel/src/HardwareThreadScheduler.cpp
@@ -22,8 +22,6 @@ namespace Kernel {
 EXTERN_C Bool hal_check_task(HAL::StackFramePtr frame);
 EXTERN_C Bool mp_register_task(HAL::StackFramePtr frame, ProcessID pid);
 
-STATIC HardwareThreadScheduler kHardwareThreadScheduler;
-
 ///! A HardwareThread class takes care of it's owned hardware thread.
 ///! It has a stack for it's core.
 
@@ -126,6 +124,7 @@ HardwareThreadScheduler::~HardwareThreadScheduler() = default;
 /// @brief Shared singleton function
 /***********************************************************************************/
 HardwareThreadScheduler& HardwareThreadScheduler::The() {
+  STATIC HardwareThreadScheduler kHardwareThreadScheduler;
   return kHardwareThreadScheduler;
 }
 
diff --git a/src/kernel/src/PE32CodeMgr.cpp b/src/kernel/src/PE32CodeMgr.cpp
index fbb761e4..375725ee 100644
--- a/src/kernel/src/PE32CodeMgr.cpp
+++ b/src/kernel/src/PE32CodeMgr.cpp
@@ -237,18 +237,18 @@ ErrorOr<VoidPtr> PE32Loader::GetBlob() {
 namespace Utils {
   ProcessID rtl_create_user_process(PE32Loader&                        exec,
                                     const UserProcess::ExecutableKind& process_kind) {
-    if (!exec.IsLoaded()) return kSchedInvalidPID;
+    if (!exec.IsLoaded()) return kCPSInvalidPID;
 
     ErrorOrAny errOrStart = exec.FindStart();
 
-    if (errOrStart.Error() != kErrorSuccess) return kSchedInvalidPID;
+    if (errOrStart.Error() != kErrorSuccess) return kCPSInvalidPID;
 
     ErrorOrAny symname = exec.FindSymbol(kPeNameSymbol, 0);
 
     if (!symname.Leak().Leak())
       symname = ErrorOr<VoidPtr>{(VoidPtr) rt_alloc_string(kPeImageStart)};
 
-    if (!symname.Leak().Leak()) return kSchedInvalidPID;
+    if (!symname.Leak().Leak()) return kCPSInvalidPID;
 
     ProcessID id =
         UserProcessScheduler::The().Spawn(reinterpret_cast<const Char*>(symname.Leak().Leak()),
@@ -256,21 +256,21 @@ namespace Utils {
 
     mm_free_ptr(symname.Leak().Leak());
 
-    if (id != kSchedInvalidPID) {
+    if (id != kCPSInvalidPID) {
       auto stacksym = exec.FindSymbol(kPeStackSizeSymbol, 0);
 
       if (!stacksym.Leak().Leak()) {
-        stacksym = ErrorOr<VoidPtr>{(VoidPtr) new UIntPtr(kSchedMaxStackSz)};
+        stacksym = ErrorOr<VoidPtr>{(VoidPtr) new UIntPtr(kCPSMaxStackSz)};
       }
 
       if (!stacksym.Leak().Leak()) {
         UserProcessScheduler::The().Remove(id);
         mm_free_ptr(stacksym.Leak().Leak());
-        return kSchedInvalidPID;
+        return kCPSInvalidPID;
       }
 
-      if ((*(volatile UIntPtr*) stacksym.Leak().Leak()) > kSchedMaxStackSz) {
-        *(volatile UIntPtr*) stacksym.Leak().Leak() = kSchedMaxStackSz;
+      if ((*(volatile UIntPtr*) stacksym.Leak().Leak()) > kCPSMaxStackSz) {
+        *(volatile UIntPtr*) stacksym.Leak().Leak() = kCPSMaxStackSz;
       }
 
       UserProcessScheduler::The().TheCurrentTeam().Leak().AsArray()[id].Kind = process_kind;
diff --git a/src/kernel/src/PEFCodeMgr.cpp b/src/kernel/src/PEFCodeMgr.cpp
index 8f2225a4..3b03c81f 100644
--- a/src/kernel/src/PEFCodeMgr.cpp
+++ b/src/kernel/src/PEFCodeMgr.cpp
@@ -301,17 +301,17 @@ ErrorOr<VoidPtr> PEFLoader::GetBlob() {
 
 ProcessID rtl_create_user_process(PEFLoader&                         exec,
                                   const UserProcess::ExecutableKind& process_kind) {
-  if (!exec.IsLoaded()) return kSchedInvalidPID;
+  if (!exec.IsLoaded()) return kCPSInvalidPID;
 
   auto errOrStart = exec.FindStart();
 
-  if (errOrStart.Error() != kErrorSuccess) return kSchedInvalidPID;
+  if (errOrStart.Error() != kErrorSuccess) return kCPSInvalidPID;
 
   auto symname = exec.FindSymbol(kPefNameSymbol, kPefCode);
 
   if (!symname.Leak().Leak()) symname = ErrorOr<VoidPtr>{(VoidPtr) rt_alloc_string(kPefImageStart)};
 
-  if (!symname.Leak().Leak()) return kSchedInvalidPID;
+  if (!symname.Leak().Leak()) return kCPSInvalidPID;
 
   ProcessID id =
       UserProcessScheduler::The().Spawn(reinterpret_cast<const Char*>(symname.Leak().Leak()),
@@ -319,21 +319,21 @@ ProcessID rtl_create_user_process(PEFLoader&                         exec,
 
   if (symname.Leak().Leak()) mm_free_ptr(symname.Leak().Leak());
 
-  if (id != kSchedInvalidPID) {
+  if (id != kCPSInvalidPID) {
     auto stacksym = exec.FindSymbol(kPefStackSizeSymbol, kPefData);
 
     if (!stacksym.Leak().Leak()) {
-      stacksym = ErrorOr<VoidPtr>{(VoidPtr) new UIntPtr(kSchedMaxStackSz)};
+      stacksym = ErrorOr<VoidPtr>{(VoidPtr) new UIntPtr(kCPSMaxStackSz)};
     }
 
     if (!stacksym.Leak().Leak()) {
       UserProcessScheduler::The().Remove(id);
       mm_free_ptr(stacksym.Leak().Leak());
-      return kSchedInvalidPID;
+      return kCPSInvalidPID;
     }
 
-    if ((*(volatile UIntPtr*) stacksym.Leak().Leak()) > kSchedMaxStackSz) {
-      *(volatile UIntPtr*) stacksym.Leak().Leak() = kSchedMaxStackSz;
+    if ((*(volatile UIntPtr*) stacksym.Leak().Leak()) > kCPSMaxStackSz) {
+      *(volatile UIntPtr*) stacksym.Leak().Leak() = kCPSMaxStackSz;
     }
 
     UserProcessScheduler::The().TheCurrentTeam().Leak().AsArray()[id].Kind = process_kind;
diff --git a/src/kernel/src/UserProcessScheduler.cpp b/src/kernel/src/UserProcessScheduler.cpp
index e7fe7398..4b8d788b 100644
--- a/src/kernel/src/UserProcessScheduler.cpp
+++ b/src/kernel/src/UserProcessScheduler.cpp
@@ -102,7 +102,7 @@ STATIC T* sched_try_go_upper_ptr_tree(T* tree) {
 /***********************************************************************************/
 
 ErrorOr<VoidPtr> UserProcess::New(SizeT sz, SizeT pad_amount) {
-  if (this->UsedMemory > kSchedMaxMemoryLimit) return ErrorOr<VoidPtr>(-kErrorHeapOutOfMemory);
+  if (this->UsedMemory > kCPSMaxMemoryLimit) return ErrorOr<VoidPtr>(-kErrorHeapOutOfMemory);
 
 #ifdef __NE_VIRTUAL_MEMORY_SUPPORT__
   auto vm_register = kKernelVM;
@@ -347,7 +347,7 @@ ProcessID UserProcessScheduler::Spawn(const Char* name, VoidPtr code, VoidPtr im
 
   ProcessID pid = this->mTeam.mProcessCur;
 
-  if (pid > kSchedProcessLimitPerTeam) {
+  if (pid > kCPSProcessLimitPerTeam) {
     return -kErrorProcessFault;
   }
 
@@ -360,12 +360,12 @@ ProcessID UserProcessScheduler::Spawn(const Char* name, VoidPtr code, VoidPtr im
 
   SizeT len = rt_string_len(name);
 
-  if (len > kSchedNameLen) {
+  if (len > kCPSNameLen) {
     return -kErrorProcessFault;
   }
 
   rt_copy_memory_safe(reinterpret_cast<VoidPtr>(const_cast<Char*>(name)), process.Name, len,
-                      kSchedNameLen);
+                      kCPSNameLen);
 
 #ifdef __NE_VIRTUAL_MEMORY_SUPPORT__
   process.VMRegister = kKernelVM;
@@ -394,7 +394,7 @@ ProcessID UserProcessScheduler::Spawn(const Char* name, VoidPtr code, VoidPtr im
                    HAL::kMMFlagsUser | HAL::kMMFlagsPresent);
 #endif  // ifdef __NE_VIRTUAL_MEMORY_SUPPORT__
 
-  process.StackSize = kSchedMaxStackSz;
+  process.StackSize = kCPSMaxStackSz;
 
   rt_set_memory(process.StackReserve, 0, process.StackSize);
 
@@ -429,8 +429,8 @@ ProcessID UserProcessScheduler::Spawn(const Char* name, VoidPtr code, VoidPtr im
 /***********************************************************************************/
 
 UserProcessScheduler& UserProcessScheduler::The() {
-  STATIC UserProcessScheduler kScheduler;
-  return kScheduler;
+  STATIC UserProcessScheduler kUserScheduler;
+  return kUserScheduler;
 }
 
 /***********************************************************************************/
@@ -443,7 +443,7 @@ UserProcessScheduler& UserProcessScheduler::The() {
 /***********************************************************************************/
 
 Void UserProcessScheduler::Remove(ProcessID process_id) {
-  if (process_id < 0 || process_id > kSchedProcessLimitPerTeam) return;
+  if (process_id < 0 || process_id > kCPSProcessLimitPerTeam) return;
   if (this->mTeam.mProcessList[process_id].Status == ProcessStatusKind::kInvalid) return;
 
   mTeam.mProcessList[process_id].Exit(kErrorSuccess);
@@ -566,7 +566,7 @@ Bool UserProcessHelper::CanBeScheduled(const UserProcess& process) {
 
   if (process.Status != ProcessStatusKind::kRunning) return No;
   if (process.Affinity == AffinityKind::kInvalid) return No;
-  if (process.StackSize > kSchedMaxStackSz) return No;
+  if (process.StackSize > kCPSMaxStackSz) return No;
   if (!process.Name[0]) return No;
   if (process.Signal.SignalID == sig_generate_unique<SIGTRAP>()) return No;
 
diff --git a/src/kernel/src/UserProcessTeam.cpp b/src/kernel/src/UserProcessTeam.cpp
index fe598795..293fd45a 100644
--- a/src/kernel/src/UserProcessTeam.cpp
+++ b/src/kernel/src/UserProcessTeam.cpp
@@ -24,7 +24,7 @@ UserProcessTeam::UserProcessTeam() {
 /// @return The list of process to schedule.
 /***********************************************************************************/
 
-Array<UserProcess, kSchedProcessLimitPerTeam>& UserProcessTeam::AsArray() {
+Array<UserProcess, kCPSProcessLimitPerTeam>& UserProcessTeam::AsArray() {
   return this->mProcessList;
 }