FIX: Fix scheduler for the task switch, separate desktop and mobile

targets.

	- Giving priority to aarch64 support.
	- The scheduler needed those fixes before proceeding to aarch64
	  support.
	- We use the register approach, which is correct here, the
	  platform code will just take those records and execute them.

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

3 files changed, 39 insertions, 62 deletions

diff --git a/dev/Kernel/src/HardwareThreadScheduler.cc b/dev/Kernel/src/HardwareThreadScheduler.cc
index 8ece31b9..91800ab7 100644
--- a/dev/Kernel/src/HardwareThreadScheduler.cc
+++ b/dev/Kernel/src/HardwareThreadScheduler.cc
@@ -4,6 +4,7 @@
 
 ------------------------------------------- */
 
+#include "NewKit/Macros.h"
 #include <ArchKit/ArchKit.h>
 #include <KernelKit/UserProcessScheduler.h>
 #include <KernelKit/HardwareThreadScheduler.h>
@@ -101,11 +102,6 @@ namespace Kernel
 	Void HardwareThread::Wake(const bool wakeup) noexcept
 	{
 		fWakeup = wakeup;
-
-		if (!fWakeup)
-			mp_hang_thread(fStack);
-		else
-			mp_wakeup_thread(fStack);
 	}
 
 	/***********************************************************************************/
@@ -116,27 +112,13 @@ namespace Kernel
 	/***********************************************************************************/
 	Bool HardwareThread::Switch(VoidPtr image, Ptr8 stack_ptr, HAL::StackFramePtr frame, const ThreadID& pid)
 	{
-		if (!frame ||
-			!image ||
-			!stack_ptr)
-			return No;
-
-		if (!this->IsWakeup())
-			return No;
-
-		if (this->IsBusy())
-			return No;
-
-		if (!hal_check_stack(frame))
-			return No;
-
 		this->fStack	 = frame;
 		this->fSourcePID = pid;
 
 		Bool ret = mp_register_process(image, stack_ptr, fStack, this->fSourcePID);
 
 		if (ret)
-			this->Busy(true);
+			this->Busy(YES);
 
 		return ret;
 	}
@@ -230,9 +212,6 @@ namespace Kernel
 	/***********************************************************************************/
 	SizeT HardwareThreadScheduler::Capacity() noexcept
 	{
-		if (fThreadList.Empty())
-			return 0UL;
-
-		return fThreadList.Capacity();
+		return fThreadList.Count();
 	}
 } // namespace Kernel
diff --git a/dev/Kernel/src/KernelMain.cc b/dev/Kernel/src/KernelMain.cc
index d62fe3b2..981866d2 100644
--- a/dev/Kernel/src/KernelMain.cc
+++ b/dev/Kernel/src/KernelMain.cc
@@ -118,7 +118,7 @@ namespace Kernel::Detail
 	};
 } // namespace Kernel::Detail
 
-/// @brief Application entrypoint.
+/// @brief Kernel entrypoint.
 /// @param Void
 /// @return Void
 EXTERN_C Kernel::Void rtl_kernel_main(Kernel::SizeT argc, char** argv, char** envp, Kernel::SizeT envp_len)
diff --git a/dev/Kernel/src/UserProcessScheduler.cc b/dev/Kernel/src/UserProcessScheduler.cc
index 5356ee65..91001b05 100644
--- a/dev/Kernel/src/UserProcessScheduler.cc
+++ b/dev/Kernel/src/UserProcessScheduler.cc
@@ -37,7 +37,7 @@ namespace Kernel
 
 	STATIC UserProcessScheduler kProcessScheduler;
 
-	UserThread::UserThread()	= default;
+	UserThread::UserThread()  = default;
 	UserThread::~UserThread() = default;
 
 	/// @brief Gets the last exit code.
@@ -352,8 +352,8 @@ namespace Kernel
 		process.ProcessParentTeam = &mTeam;
 
 		process.ProcessId = pid;
-		process.Status	   = ProcessStatusKind::kStarting;
-		process.PTime	   = (UIntPtr)AffinityKind::kStandard;
+		process.Status	  = ProcessStatusKind::kStarting;
+		process.PTime	  = (UIntPtr)AffinityKind::kStandard;
 
 		kcout << "PID: " << number(process.ProcessId) << endl;
 		kcout << "Name: " << process.Name << endl;
@@ -441,8 +441,12 @@ namespace Kernel
 				kcout << "Switch to '" << process.Name << "'.\r";
 
 				// tell helper to find a core to schedule on.
-				UserProcessHelper::Switch(process.Image.fCode, &process.StackReserve[process.StackSize - 1], process.StackFrame,
-											   process.ProcessId);
+				if (!UserProcessHelper::Switch(process.Image.fCode, &process.StackReserve[process.StackSize - 1], process.StackFrame,
+											   process.ProcessId))
+				{
+					kcout << "Invalid process.\r";
+					process.Crash();
+				}
 			}
 			else
 			{
@@ -525,50 +529,44 @@ namespace Kernel
 
 	Bool UserProcessHelper::Switch(VoidPtr image_ptr, UInt8* stack, HAL::StackFramePtr frame_ptr, const PID& new_pid)
 	{
-		if (!stack || !frame_ptr || !image_ptr)
-			return No;
-
-		if (!mm_is_valid_heap(image_ptr))
-			return No;
-
 		for (SizeT index = 0UL; index < HardwareThreadScheduler::The().Capacity(); ++index)
 		{
-			if (!HardwareThreadScheduler::The()[index].Leak())
+			if (HardwareThreadScheduler::The()[index].Leak()->Kind() == kInvalidAP ||
+				HardwareThreadScheduler::The()[index].Leak()->Kind() == kAPBoot)
 				continue;
 
-			if (HardwareThreadScheduler::The()[index].Leak()->Kind() == kInvalidAP)
-				continue;
+			PID prev_pid									 = UserProcessHelper::TheCurrentPID();
+			UserProcessHelper::TheCurrentPID().Leak().Leak() = new_pid;
 
-			if (HardwareThreadScheduler::The()[index].Leak()->Kind() !=
-					ThreadKind::kAPBoot &&
-				HardwareThreadScheduler::The()[index].Leak()->Kind() !=
-					ThreadKind::kAPSystemReserved)
-			{
-				PID prev_pid									 = UserProcessHelper::TheCurrentPID();
-				UserProcessHelper::TheCurrentPID().Leak().Leak() = new_pid;
+			////////////////////////////////////////////////////////////
+			///	Prepare task switch.								 ///
+			////////////////////////////////////////////////////////////
 
-				////////////////////////////////////////////////////////////
-				///	Prepare task switch.								 ///
-				////////////////////////////////////////////////////////////
+			HardwareThreadScheduler::The()[index].Leak()->Wake(YES);
+			HardwareThreadScheduler::The()[index].Leak()->Busy(NO);
 
-				auto prev_ptime										 = HardwareThreadScheduler::The()[index].Leak()->fPTime;
-				HardwareThreadScheduler::The()[index].Leak()->fPTime = UserProcessScheduler::The().CurrentTeam().AsArray()[new_pid].PTime;
-				Bool ret											 = HardwareThreadScheduler::The()[index].Leak()->Switch(image_ptr, stack, frame_ptr, new_pid);
+			auto prev_ptime										 = HardwareThreadScheduler::The()[index].Leak()->fPTime;
+			HardwareThreadScheduler::The()[index].Leak()->fPTime = UserProcessScheduler::The().CurrentTeam().AsArray()[new_pid].PTime;
 
-				////////////////////////////////////////////////////////////
-				///	Rollback on fail.    								 ///
-				////////////////////////////////////////////////////////////
-				if (!ret)
-				{
-					HardwareThreadScheduler::The()[index].Leak()->fPTime = prev_ptime;
-					UserProcessHelper::TheCurrentPID().Leak().Leak()	 = prev_pid;
+			Bool ret											 = HardwareThreadScheduler::The()[index].Leak()->Switch(image_ptr, stack, frame_ptr, new_pid);
 
-					return false;
-				}
+			////////////////////////////////////////////////////////////
+			///	Rollback on fail.    								 ///
+			////////////////////////////////////////////////////////////
+			if (!ret)
+			{
+				HardwareThreadScheduler::The()[index].Leak()->fPTime = prev_ptime;
+				UserProcessHelper::TheCurrentPID().Leak().Leak()	 = prev_pid;
+
+				HardwareThreadScheduler::The()[index].Leak()->Busy(NO);
 			}
+
+			HardwareThreadScheduler::The()[index].Leak()->Wake(NO);
+
+			return Yes;
 		}
 
-		return false;
+		return No;
 	}
 
 	////////////////////////////////////////////////////////////