FIX: CUSA and improved algorithm.

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

6 files changed, 107 insertions, 132 deletions

diff --git a/dev/Kernel/src/CodeMgr.cc b/dev/Kernel/src/CodeMgr.cc
index ccf0659b..6077ed82 100644
--- a/dev/Kernel/src/CodeMgr.cc
+++ b/dev/Kernel/src/CodeMgr.cc
@@ -23,20 +23,6 @@ namespace Kernel
 			*process_name == 0)
 			return kProcessInvalidID;
 
-		UserProcess* process_hdr = new UserProcess();
-
-		process_hdr->Image.fCode = reinterpret_cast<VoidPtr>(main);
-		process_hdr->Kind		 = UserProcess::kExectuableKind;
-		process_hdr->StackSize	 = kib_cast(8);
-
-		rt_set_memory(process_hdr->Name, 0, kProcessNameLen);
-		rt_copy_memory((VoidPtr)process_name, process_hdr->Name, rt_string_len(process_name));
-
-		ProcessID id = UserProcessScheduler::The().Spawn(process_hdr);
-
-		delete process_hdr;
-		process_hdr = nullptr;
-
-		return id;
+		return UserProcessScheduler::The().Spawn(process_name, reinterpret_cast<VoidPtr>(main), nullptr);
 	}
 } // namespace Kernel
diff --git a/dev/Kernel/src/IPEFDLLObject.cc b/dev/Kernel/src/IPEFDLLObject.cc
index acc53705..1b8d2451 100644
--- a/dev/Kernel/src/IPEFDLLObject.cc
+++ b/dev/Kernel/src/IPEFDLLObject.cc
@@ -39,13 +39,13 @@ using namespace Kernel;
 /** @brief Library initializer. */
 /***********************************************************************************/
 
-EXTERN_C IDLL rtl_init_dylib(UserProcess* header)
+EXTERN_C IDLL rtl_init_dylib(UserThread& header)
 {
 	IDLL dll_obj = tls_new_class<IPEFDLLObject>();
 
 	if (!dll_obj)
 	{
-		header->Crash();
+		header.Crash();
 		return nullptr;
 	}
 
@@ -54,18 +54,18 @@ EXTERN_C IDLL rtl_init_dylib(UserProcess* header)
 	if (!dll_obj->Get())
 	{
 		tls_delete_class(dll_obj);
-		header->Crash();
+		header.Crash();
 
 		return nullptr;
 	}
 
 	dll_obj->Get()->ImageObject =
-		header->Image.fBlob;
+		header.Image.fBlob;
 
 	if (!dll_obj->Get()->ImageObject)
 	{
 		tls_delete_class(dll_obj);
-		header->Crash();
+		header.Crash();
 
 		return nullptr;
 	}
@@ -83,7 +83,7 @@ EXTERN_C IDLL rtl_init_dylib(UserProcess* header)
 /** @param successful Reports if successful or not. */
 /***********************************************************************************/
 
-EXTERN_C Void rtl_fini_dylib(UserProcess* header, IDLL dll_obj, Bool* successful)
+EXTERN_C Void rtl_fini_dylib(UserThread& header, IDLL dll_obj, Bool* successful)
 {
 	MUST_PASS(successful);
 
@@ -91,7 +91,7 @@ EXTERN_C Void rtl_fini_dylib(UserProcess* header, IDLL dll_obj, Bool* successful
 	if (dll_obj == nullptr)
 	{
 		*successful = false;
-		header->Crash();
+		header.Crash();
 	}
 
 	delete dll_obj->Get();
diff --git a/dev/Kernel/src/PEFCodeMgr.cc b/dev/Kernel/src/PEFCodeMgr.cc
index 63925c6c..17f7f895 100644
--- a/dev/Kernel/src/PEFCodeMgr.cc
+++ b/dev/Kernel/src/PEFCodeMgr.cc
@@ -246,38 +246,24 @@ namespace Kernel
 
 	namespace Utils
 	{
-		ProcessID rtl_create_process(PEFLoader& exec, const Int32& procKind) noexcept
+		ProcessID rtl_create_process(PEFLoader& exec, const Int32& process_kind) noexcept
 		{
 			auto errOrStart = exec.FindStart();
 
 			if (errOrStart.Error() != kErrorSuccess)
 				return kProcessInvalidID;
 
-			UserProcess* proc = new UserProcess();
+			UserThread process;
 
-			proc->Kind		  = procKind;
-			proc->Image.fCode = errOrStart.Leak().Leak();
-			proc->Image.fBlob = exec.GetBlob().Leak().Leak();
-			proc->StackSize	  = *(UIntPtr*)exec.FindSymbol(kPefStackSizeSymbol, kPefData);
-			proc->MemoryLimit = *(UIntPtr*)exec.FindSymbol(kPefHeapSizeSymbol, kPefData);
-			proc->PTime		  = 0UL;
+			auto id = UserProcessScheduler::The().Spawn(reinterpret_cast<const Char*>(exec.FindSymbol(kPefNameSymbol, kPefData)), errOrStart.Leak().Leak(), exec.GetBlob().Leak().Leak());
 
-			rt_set_memory(proc->Name, 0, kProcessNameLen);
-
-			if (exec.FindSymbol(kPefNameSymbol, kPefData))
-				rt_copy_memory(exec.FindSymbol(kPefNameSymbol, kPefData), proc->Name, rt_string_len((Char*)exec.FindSymbol(kPefNameSymbol, kPefData)));
-
-			if (!proc->StackSize)
+			if (id != kProcessInvalidID)
 			{
-				const auto kDefaultStackSizeMib = 8;
-				proc->StackSize					= mib_cast(kDefaultStackSizeMib);
+				UserProcessScheduler::The().CurrentTeam().AsArray()[id].Kind = process_kind; 
+				UserProcessScheduler::The().CurrentTeam().AsArray()[id].StackSize = *(UIntPtr*)exec.FindSymbol(kPefStackSizeSymbol, kPefData);
+				UserProcessScheduler::The().CurrentTeam().AsArray()[id].MemoryLimit = *(UIntPtr*)exec.FindSymbol(kPefHeapSizeSymbol, kPefData);
 			}
 
-			auto id = UserProcessScheduler::The().Spawn(proc);
-
-			if (id == kProcessInvalidID)
-				delete proc;
-
 			return id;
 		}
 	} // namespace Utils
diff --git a/dev/Kernel/src/Semaphore.cc b/dev/Kernel/src/Semaphore.cc
index 257fed48..b63d5be3 100644
--- a/dev/Kernel/src/Semaphore.cc
+++ b/dev/Kernel/src/Semaphore.cc
@@ -15,7 +15,7 @@ namespace Kernel
 	Bool Semaphore::Unlock() noexcept
 	{
 		if (fLockingProcess)
-			fLockingProcess = nullptr;
+			fLockingProcess = UserThread();
 		else
 			return No;
 
@@ -25,7 +25,7 @@ namespace Kernel
 	/***********************************************************************************/
 	/// @brief Locks process in the semaphore.
 	/***********************************************************************************/
-	Bool Semaphore::Lock(UserProcess* process)
+	Bool Semaphore::Lock(UserThread& process)
 	{
 		if (!process || fLockingProcess)
 			return No;
@@ -46,11 +46,8 @@ namespace Kernel
 	/***********************************************************************************/
 	/// @brief Try lock or wait.
 	/***********************************************************************************/
-	Bool Semaphore::LockOrWait(UserProcess* process, TimerInterface* timer)
+	Bool Semaphore::LockOrWait(UserThread& process, TimerInterface* timer)
 	{
-		if (process == nullptr)
-			return No;
-
 		if (timer == nullptr)
 			return No;
 
diff --git a/dev/Kernel/src/UserProcessScheduler.cc b/dev/Kernel/src/UserProcessScheduler.cc
index 03fa58f6..5356ee65 100644
--- a/dev/Kernel/src/UserProcessScheduler.cc
+++ b/dev/Kernel/src/UserProcessScheduler.cc
@@ -12,6 +12,7 @@
 /// @brief Low level/Ring-3 process scheduler.
 /***********************************************************************************/
 
+#include "NewKit/Macros.h"
 #include <KernelKit/UserProcessScheduler.h>
 #include <KernelKit/HardwareThreadScheduler.h>
 #include <KernelKit/IPEFDLLObject.h>
@@ -36,8 +37,8 @@ namespace Kernel
 
 	STATIC UserProcessScheduler kProcessScheduler;
 
-	UserProcess::UserProcess()	= default;
-	UserProcess::~UserProcess() = default;
+	UserThread::UserThread()	= default;
+	UserThread::~UserThread() = default;
 
 	/// @brief Gets the last exit code.
 	/// @note Not thread-safe.
@@ -48,10 +49,10 @@ namespace Kernel
 	}
 
 	/***********************************************************************************/
-	/// @brief Crashes the current process->
+	/// @brief Crashes the current process.
 	/***********************************************************************************/
 
-	Void UserProcess::Crash()
+	Void UserThread::Crash()
 	{
 		if (this->Status != ProcessStatusKind::kRunning)
 			return;
@@ -64,7 +65,7 @@ namespace Kernel
 	//! @brief boolean operator, check status.
 	/***********************************************************************************/
 
-	UserProcess::operator bool()
+	UserThread::operator bool()
 	{
 		return this->Status == ProcessStatusKind::kRunning;
 	}
@@ -75,7 +76,7 @@ namespace Kernel
 	/// @return Int32 the last exit code.
 	/***********************************************************************************/
 
-	const UInt32& UserProcess::GetExitCode() noexcept
+	const UInt32& UserThread::GetExitCode() noexcept
 	{
 		return this->fLastExitCode;
 	}
@@ -84,7 +85,7 @@ namespace Kernel
 	/// @brief Error code variable getter.
 	/***********************************************************************************/
 
-	Int32& UserProcess::GetLocalCode() noexcept
+	Int32& UserThread::GetLocalCode() noexcept
 	{
 		return this->fLocalCode;
 	}
@@ -94,7 +95,7 @@ namespace Kernel
 	/// @param should_wakeup if the program shall wakeup or not.
 	/***********************************************************************************/
 
-	Void UserProcess::Wake(const bool should_wakeup)
+	Void UserThread::Wake(const bool should_wakeup)
 	{
 		this->Status =
 			should_wakeup ? ProcessStatusKind::kRunning : ProcessStatusKind::kFrozen;
@@ -104,7 +105,7 @@ namespace Kernel
 	/** @brief Add pointer to entry. */
 	/***********************************************************************************/
 
-	ErrorOr<VoidPtr> UserProcess::New(const SizeT& sz, const SizeT& pad_amount)
+	ErrorOr<VoidPtr> UserThread::New(const SizeT& sz, const SizeT& pad_amount)
 	{
 #ifdef __ZKA_AMD64__
 		auto vm_register = hal_read_cr3();
@@ -119,7 +120,7 @@ namespace Kernel
 
 		if (!this->ProcessMemoryHeap)
 		{
-			this->ProcessMemoryHeap = new UserProcess::ProcessMemoryHeapList();
+			this->ProcessMemoryHeap = new UserThread::ProcessMemoryHeapList();
 
 			this->ProcessMemoryHeap->MemoryEntryPad	 = pad_amount;
 			this->ProcessMemoryHeap->MemoryEntrySize = sz;
@@ -156,36 +157,36 @@ namespace Kernel
 	}
 
 	/***********************************************************************************/
-	/// @brief Gets the name of the current process->
+	/// @brief Gets the name of the current process.
 	/***********************************************************************************/
 
-	const Char* UserProcess::GetName() noexcept
+	const Char* UserThread::GetName() noexcept
 	{
 		return this->Name;
 	}
 
 	/***********************************************************************************/
-	/// @brief Gets the owner of the process->
+	/// @brief Gets the owner of the process.
 	/***********************************************************************************/
 
-	const User* UserProcess::GetOwner() noexcept
+	const User* UserThread::GetOwner() noexcept
 	{
 		return this->Owner;
 	}
 
-	/// @brief UserProcess status getter.
-	const ProcessStatusKind& UserProcess::GetStatus() noexcept
+	/// @brief UserThread status getter.
+	const ProcessStatusKind& UserThread::GetStatus() noexcept
 	{
 		return this->Status;
 	}
 
 	/***********************************************************************************/
 	/**
-	@brief Affinity is the time slot allowed for the process->
+	@brief Affinity is the time slot allowed for the process.
 	*/
 	/***********************************************************************************/
 
-	const AffinityKind& UserProcess::GetAffinity() noexcept
+	const AffinityKind& UserThread::GetAffinity() noexcept
 	{
 		return this->Affinity;
 	}
@@ -197,7 +198,7 @@ namespace Kernel
 	*/
 	/***********************************************************************************/
 
-	Void UserProcess::Exit(const Int32& exit_code)
+	Void UserThread::Exit(const Int32& exit_code)
 	{
 		this->Status		= exit_code > 0 ? ProcessStatusKind::kKilled : ProcessStatusKind::kFrozen;
 		this->fLastExitCode = exit_code;
@@ -252,7 +253,7 @@ namespace Kernel
 		{
 			Bool success = false;
 
-			rtl_fini_dylib(this, reinterpret_cast<IPEFDLLObject*>(this->DylibDelegate), &success);
+			rtl_fini_dylib(*this, reinterpret_cast<IPEFDLLObject*>(this->DylibDelegate), &success);
 
 			if (!success)
 			{
@@ -279,14 +280,30 @@ namespace Kernel
 	/// @return the process index inside the team.
 	/***********************************************************************************/
 
-	ProcessID UserProcessScheduler::Spawn(UserProcess* process)
+	ProcessID UserProcessScheduler::Spawn(const Char* name, VoidPtr code, VoidPtr image)
 	{
+		ProcessID pid = this->mTeam.mProcessCount;
+
+		if (pid > kSchedProcessLimitPerTeam)
+		{
+			return kErrorProcessFault;
+		}
+
+		++this->mTeam.mProcessCount;
+
+		UserThread& process = this->mTeam.mProcessList[pid];
+
+		process.Image.fCode = code;
+		process.Image.fBlob = image;
+
+		rt_copy_memory(reinterpret_cast<VoidPtr>(const_cast<Char*>(name)), process.Name, rt_string_len(name));
+
 #ifdef __ZKA_AMD64__
-		process->VMRegister = new PDE();
+		process.VMRegister = new PDE();
 
-		if (!process->VMRegister)
+		if (!process.VMRegister)
 		{
-			process->Crash();
+			process.Crash();
 			return kErrorProcessFault;
 		}
 
@@ -294,14 +311,14 @@ namespace Kernel
 		flags |= HAL::kMMFlagsWr;
 		flags |= HAL::kMMFlagsUser;
 
-		HAL::mm_map_page((VoidPtr)process->VMRegister, flags);
+		HAL::mm_map_page((VoidPtr)process.VMRegister, flags);
 #endif // __ZKA_AMD64__
 
-		process->StackFrame = new HAL::StackFrame();
+		process.StackFrame = new HAL::StackFrame();
 
-		if (!process->StackFrame)
+		if (!process.StackFrame)
 		{
-			process->Crash();
+			process.Crash();
 			return kErrorProcessFault;
 		}
 
@@ -309,51 +326,39 @@ namespace Kernel
 		flags |= HAL::kMMFlagsWr;
 		flags |= HAL::kMMFlagsUser;
 
-		HAL::mm_map_page((VoidPtr)process->StackFrame, flags);
+		HAL::mm_map_page((VoidPtr)process.StackFrame, flags);
 
 		// Create heap according to type of process.
-		if (process->Kind == UserProcess::kExectuableDLLKind)
+		if (process.Kind == UserThread::kExectuableDLLKind)
 		{
-			process->DylibDelegate = rtl_init_dylib(process);
-			MUST_PASS(process->DylibDelegate);
+			process.DylibDelegate = rtl_init_dylib(process);
+			MUST_PASS(process.DylibDelegate);
 		}
 
-		process->StackReserve = new UInt8[process->StackSize];
+		process.StackReserve = new UInt8[process.StackSize];
 
 		flags = HAL::kMMFlagsPresent;
 		flags |= HAL::kMMFlagsWr;
 		flags |= HAL::kMMFlagsUser;
 
-		HAL::mm_map_page((VoidPtr)process->StackReserve, flags);
+		HAL::mm_map_page((VoidPtr)process.StackReserve, flags);
 
-		if (!process->StackReserve)
+		if (!process.StackReserve)
 		{
-			process->Crash();
-			return -kErrorProcessFault;
+			process.Crash();
+			return kErrorProcessFault;
 		}
 
-		ProcessID pid = this->mTeam.mProcessCount;
-
-		if (pid > kSchedProcessLimitPerTeam &&
-			pid != (kSchedProcessLimitPerTeam + 1))
-		{
-			this->mTeam.mProcessCount = 0;
-			pid = 0UL;
-		}
+		process.ProcessParentTeam = &mTeam;
 
-		++this->mTeam.mProcessCount;
+		process.ProcessId = pid;
+		process.Status	   = ProcessStatusKind::kStarting;
+		process.PTime	   = (UIntPtr)AffinityKind::kStandard;
 
-		process->ProcessParentTeam = &mTeam;
+		kcout << "PID: " << number(process.ProcessId) << endl;
+		kcout << "Name: " << process.Name << endl;
 
-		process->ProcessId = pid;
-		process->Status	   = ProcessStatusKind::kStarting;
-		process->PTime	   = (UIntPtr)AffinityKind::kStandard;
-
-		this->mTeam.mProcessList.Assign(pid, process);
-
-		kcout << "PID: " << number(process->ProcessId) << endl;
-
-		return process->ProcessId;
+		return pid;
 	}
 
 	/***********************************************************************************/
@@ -380,7 +385,7 @@ namespace Kernel
 		if (process_id > mTeam.mProcessList.Count())
 			return No;
 
-		mTeam.mProcessList[process_id]->Exit(0);
+		mTeam.mProcessList[process_id].Exit(0);
 
 		return Yes;
 	}
@@ -426,25 +431,22 @@ namespace Kernel
 			auto process = mTeam.AsArray()[process_index];
 
 			//! check if process needs to be scheduled.
-			if (process && UserProcessHelper::CanBeScheduled(process))
+			if (UserProcessHelper::CanBeScheduled(process))
 			{
 				// Set current process header.
 				this->GetCurrentProcess() = process;
 
-				process->PTime = static_cast<Int32>(process->Affinity);
+				process.PTime = static_cast<Int32>(process.Affinity);
 
-				kcout << "Switch to '" << process->Name << "'.\r";
+				kcout << "Switch to '" << process.Name << "'.\r";
 
 				// tell helper to find a core to schedule on.
-				if (!UserProcessHelper::Switch(process->Image.fCode, &process->StackReserve[process->StackSize - 1], process->StackFrame,
-											   process->ProcessId))
-				{
-					process->Crash();
-				}
+				UserProcessHelper::Switch(process.Image.fCode, &process.StackReserve[process.StackSize - 1], process.StackFrame,
+											   process.ProcessId);
 			}
 			else
 			{
-				--process->PTime;
+				--process.PTime;
 			}
 		}
 
@@ -460,15 +462,15 @@ namespace Kernel
 
 	/// @internal
 
-	/// @brief Gets current running process->
+	/// @brief Gets current running process.
 	/// @return
-	Ref<UserProcess>& UserProcessScheduler::GetCurrentProcess()
+	Ref<UserThread>& UserProcessScheduler::GetCurrentProcess()
 	{
 		return mTeam.AsRef();
 	}
 
 	/// @brief Current proccess id getter.
-	/// @return UserProcess ID integer.
+	/// @return UserThread ID integer.
 	ErrorOr<PID> UserProcessHelper::TheCurrentPID()
 	{
 		if (!kProcessScheduler.GetCurrentProcess())
@@ -482,23 +484,24 @@ namespace Kernel
 	/// @param process the process reference.
 	/// @retval true can be schedulded.
 	/// @retval false cannot be schedulded.
-	Bool UserProcessHelper::CanBeScheduled(const UserProcess* process)
+	Bool UserProcessHelper::CanBeScheduled(const UserThread& process)
 	{
-		if (process->Status == ProcessStatusKind::kKilled ||
-			process->Status == ProcessStatusKind::kFinished ||
-			process->Status == ProcessStatusKind::kFrozen)
+		if (process.Status == ProcessStatusKind::kKilled ||
+			process.Status == ProcessStatusKind::kFinished ||
+			process.Status == ProcessStatusKind::kStarting ||
+			process.Status == ProcessStatusKind::kFrozen)
 			return No;
 
-		if (process->Status == ProcessStatusKind::kInvalid)
+		if (process.Status == ProcessStatusKind::kInvalid)
 			return No;
 
-		if (!process->Image.fCode)
+		if (!process.Image.fCode)
 			return No;
 
-		if (!process->Name[0])
+		if (!process.Name[0])
 			return No;
 
-		return process->PTime < 1;
+		return process.PTime < 1;
 	}
 
 	/***********************************************************************************/
@@ -549,7 +552,7 @@ namespace Kernel
 				////////////////////////////////////////////////////////////
 
 				auto prev_ptime										 = HardwareThreadScheduler::The()[index].Leak()->fPTime;
-				HardwareThreadScheduler::The()[index].Leak()->fPTime = UserProcessScheduler::The().CurrentTeam().AsArray()[new_pid]->PTime;
+				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);
 
 				////////////////////////////////////////////////////////////
@@ -560,7 +563,7 @@ namespace Kernel
 					HardwareThreadScheduler::The()[index].Leak()->fPTime = prev_ptime;
 					UserProcessHelper::TheCurrentPID().Leak().Leak()	 = prev_pid;
 
-					continue;
+					return false;
 				}
 			}
 		}
diff --git a/dev/Kernel/src/UserProcessTeam.cc b/dev/Kernel/src/UserProcessTeam.cc
index 25b9daac..a41160cc 100644
--- a/dev/Kernel/src/UserProcessTeam.cc
+++ b/dev/Kernel/src/UserProcessTeam.cc
@@ -17,16 +17,19 @@ namespace Kernel
 	{
 		for (SizeT i = 0U; i < this->mProcessList.Count(); ++i)
 		{
-			this->mProcessList[i] = nullptr;
+			this->mProcessList[i] = UserThread();
+			this->mProcessList[i].Status = ProcessStatusKind::kKilled;
 		}
+
+		this->mProcessCount = 0UL;
 	}
 
 	/***********************************************************************************/
-	/// @brief UserProcess list array getter.
+	/// @brief UserThread list array getter.
 	/// @return The list of process to schedule.
 	/***********************************************************************************/
 
-	Array<UserProcess*, kSchedProcessLimitPerTeam>& UserProcessTeam::AsArray()
+	Array<UserThread, kSchedProcessLimitPerTeam>& UserProcessTeam::AsArray()
 	{
 		return this->mProcessList;
 	}
@@ -46,7 +49,7 @@ namespace Kernel
 	/// @return The current process header.
 	/***********************************************************************************/
 
-	Ref<UserProcess>& UserProcessTeam::AsRef()
+	Ref<UserThread>& UserProcessTeam::AsRef()
 	{
 		return this->mCurrentProcess;
 	}