dev, scheduler, ahci, dev: Refactor scheduler, and fix minor mistakes.

Add kDeviceTypeATA in DeviceMgr.h, making NeKernel aware that ATA
devices can exist too.

The scheduler now won't have to reimplement new classes, I refactor the
names to signal that, and they're already generic enough to signal that.

The AHCI-Generic driver got cleaned up of any irrelevant code, such as
aligning the newly allocated pointer.

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

6 files changed, 38 insertions, 38 deletions

diff --git a/dev/kernel/src/BinaryMutex.cc b/dev/kernel/src/BinaryMutex.cc
index ea6d5408..1ed08fa9 100644
--- a/dev/kernel/src/BinaryMutex.cc
+++ b/dev/kernel/src/BinaryMutex.cc
@@ -16,7 +16,7 @@ namespace Kernel
 	{
 		if (fLockingProcess)
 		{
-			fLockingProcess		   = UserProcess();
+			fLockingProcess		   = Process();
 			fLockingProcess.Status = ProcessStatusKind::kFrozen;
 			return Yes;
 		}
@@ -27,7 +27,7 @@ namespace Kernel
 	/***********************************************************************************/
 	/// @brief Locks process in the semaphore.
 	/***********************************************************************************/
-	Bool BinaryMutex::Lock(UserProcess& process)
+	Bool BinaryMutex::Lock(Process& process)
 	{
 		if (!process || fLockingProcess)
 			return No;
@@ -48,7 +48,7 @@ namespace Kernel
 	/***********************************************************************************/
 	/// @brief Try lock or wait.
 	/***********************************************************************************/
-	Bool BinaryMutex::LockOrWait(UserProcess& process, TimerInterface* timer)
+	Bool BinaryMutex::LockOrWait(Process& process, TimerInterface* timer)
 	{
 		if (timer == nullptr)
 			return No;
diff --git a/dev/kernel/src/IPEFDylibObject.cc b/dev/kernel/src/IPEFDylibObject.cc
index a42d267a..3dd956c9 100644
--- a/dev/kernel/src/IPEFDylibObject.cc
+++ b/dev/kernel/src/IPEFDylibObject.cc
@@ -41,7 +41,7 @@ using namespace Kernel;
 /** @brief Library initializer. */
 /***********************************************************************************/
 
-EXTERN_C IDylibRef rtl_init_dylib(UserProcess& process)
+EXTERN_C IDylibRef rtl_init_dylib(Process& process)
 {
 	IDylibRef dll_obj = tls_new_class<IPEFDylibObject>();
 
@@ -91,7 +91,7 @@ EXTERN_C IDylibRef rtl_init_dylib(UserProcess& process)
 /** @param successful Reports if successful or not. */
 /***********************************************************************************/
 
-EXTERN_C Void rtl_fini_dylib(UserProcess& process, IDylibRef dll_obj, BOOL* successful)
+EXTERN_C Void rtl_fini_dylib(Process& process, IDylibRef dll_obj, BOOL* successful)
 {
 	MUST_PASS(successful);
 
diff --git a/dev/kernel/src/Network/IPCAddr.cc b/dev/kernel/src/Network/IPCAddr.cc
index 80a14264..a56aec14 100644
--- a/dev/kernel/src/Network/IPCAddr.cc
+++ b/dev/kernel/src/Network/IPCAddr.cc
@@ -12,21 +12,21 @@ namespace Kernel
 {
 	bool IPC_ADDR::operator==(const IPC_ADDR& addr) noexcept
 	{
-		return addr.UserProcessID == this->UserProcessID && addr.UserProcessTeam == this->UserProcessTeam;
+		return addr.UserProcessID == this->UserProcessID && addr.ProcessTeam == this->ProcessTeam;
 	}
 
 	bool IPC_ADDR::operator==(IPC_ADDR& addr) noexcept
 	{
-		return addr.UserProcessID == this->UserProcessID && addr.UserProcessTeam == this->UserProcessTeam;
+		return addr.UserProcessID == this->UserProcessID && addr.ProcessTeam == this->ProcessTeam;
 	}
 
 	bool IPC_ADDR::operator!=(const IPC_ADDR& addr) noexcept
 	{
-		return addr.UserProcessID != this->UserProcessID || addr.UserProcessTeam != this->UserProcessTeam;
+		return addr.UserProcessID != this->UserProcessID || addr.ProcessTeam != this->ProcessTeam;
 	}
 
 	bool IPC_ADDR::operator!=(IPC_ADDR& addr) noexcept
 	{
-		return addr.UserProcessID != this->UserProcessID || addr.UserProcessTeam != this->UserProcessTeam;
+		return addr.UserProcessID != this->UserProcessID || addr.ProcessTeam != this->ProcessTeam;
 	}
 } // namespace Kernel
diff --git a/dev/kernel/src/Network/IPCMsg.cc b/dev/kernel/src/Network/IPCMsg.cc
index 06073214..0f3e61e5 100644
--- a/dev/kernel/src/Network/IPCMsg.cc
+++ b/dev/kernel/src/Network/IPCMsg.cc
@@ -91,10 +91,10 @@ namespace Kernel
 			(*pckt_in)->IpcPacketSize = sizeof(IPC_MSG);
 
 			(*pckt_in)->IpcTo.UserProcessID	  = 0;
-			(*pckt_in)->IpcTo.UserProcessTeam = 0;
+			(*pckt_in)->IpcTo.ProcessTeam = 0;
 
 			(*pckt_in)->IpcFrom.UserProcessID	= 0;
-			(*pckt_in)->IpcFrom.UserProcessTeam = 0;
+			(*pckt_in)->IpcFrom.ProcessTeam = 0;
 
 			return Yes;
 		}
diff --git a/dev/kernel/src/ProcessTeam.cc b/dev/kernel/src/ProcessTeam.cc
index 000f76d6..87d21d67 100644
--- a/dev/kernel/src/ProcessTeam.cc
+++ b/dev/kernel/src/ProcessTeam.cc
@@ -5,7 +5,7 @@
 ------------------------------------------- */
 
 /***********************************************************************************/
-/// @file UserProcessTeam.cc
+/// @file ProcessTeam.cc
 /// @brief Process teams implementation.
 /***********************************************************************************/
 
@@ -13,11 +13,11 @@
 
 namespace Kernel
 {
-	UserProcessTeam::UserProcessTeam()
+	ProcessTeam::ProcessTeam()
 	{
 		for (SizeT i = 0U; i < this->mProcessList.Count(); ++i)
 		{
-			this->mProcessList[i]		 = UserProcess();
+			this->mProcessList[i]		 = Process();
 			this->mProcessList[i].PTime	 = 0;
 			this->mProcessList[i].Status = ProcessStatusKind::kKilled;
 		}
@@ -26,11 +26,11 @@ namespace Kernel
 	}
 
 	/***********************************************************************************/
-	/// @brief UserProcess list array getter.
+	/// @brief Process list array getter.
 	/// @return The list of process to schedule.
 	/***********************************************************************************/
 
-	Array<UserProcess, kSchedProcessLimitPerTeam>& UserProcessTeam::AsArray()
+	Array<Process, kSchedProcessLimitPerTeam>& ProcessTeam::AsArray()
 	{
 		return this->mProcessList;
 	}
@@ -40,7 +40,7 @@ namespace Kernel
 	/// @return The team's ID.
 	/***********************************************************************************/
 
-	ProcessID& UserProcessTeam::Id() noexcept
+	ProcessID& ProcessTeam::Id() noexcept
 	{
 		return this->mTeamId;
 	}
@@ -50,7 +50,7 @@ namespace Kernel
 	/// @return The current process header.
 	/***********************************************************************************/
 
-	Ref<UserProcess>& UserProcessTeam::AsRef()
+	Ref<Process>& ProcessTeam::AsRef()
 	{
 		return this->mCurrentProcess;
 	}
diff --git a/dev/kernel/src/UserProcessScheduler.cc b/dev/kernel/src/UserProcessScheduler.cc
index 56b41436..5f627dd5 100644
--- a/dev/kernel/src/UserProcessScheduler.cc
+++ b/dev/kernel/src/UserProcessScheduler.cc
@@ -37,8 +37,8 @@ namespace Kernel
 
 	STATIC UserProcessScheduler kProcessScheduler;
 
-	UserProcess::UserProcess()	= default;
-	UserProcess::~UserProcess() = default;
+	Process::Process()	= default;
+	Process::~Process() = default;
 
 	/// @brief Gets the last exit code.
 	/// @note Not thread-safe.
@@ -53,7 +53,7 @@ namespace Kernel
 	/// @brief Crashes the current process.
 	/***********************************************************************************/
 
-	Void UserProcess::Crash()
+	Void Process::Crash()
 	{
 		if (this->Status != ProcessStatusKind::kRunning)
 			return;
@@ -66,7 +66,7 @@ namespace Kernel
 	/// @brief boolean operator, check status.
 	/***********************************************************************************/
 
-	UserProcess::operator bool()
+	Process::operator bool()
 	{
 		return this->Status == ProcessStatusKind::kRunning;
 	}
@@ -77,7 +77,7 @@ namespace Kernel
 	/// @return Int32 the last exit code.
 	/***********************************************************************************/
 
-	const UInt32& UserProcess::GetExitCode() noexcept
+	const UInt32& Process::GetExitCode() noexcept
 	{
 		return this->fLastExitCode;
 	}
@@ -86,7 +86,7 @@ namespace Kernel
 	/// @brief Error code variable getter.
 	/***********************************************************************************/
 
-	Int32& UserProcess::GetLocalCode() noexcept
+	Int32& Process::GetLocalCode() noexcept
 	{
 		return this->fLocalCode;
 	}
@@ -96,7 +96,7 @@ namespace Kernel
 	/// @param should_wakeup if the program shall wakeup or not.
 	/***********************************************************************************/
 
-	Void UserProcess::Wake(Bool should_wakeup)
+	Void Process::Wake(Bool should_wakeup)
 	{
 		this->Status =
 			should_wakeup ? ProcessStatusKind::kRunning : ProcessStatusKind::kFrozen;
@@ -106,7 +106,7 @@ namespace Kernel
 	/** @brief Allocate pointer to track list. */
 	/***********************************************************************************/
 
-	ErrorOr<VoidPtr> UserProcess::New(SizeT sz, SizeT pad_amount)
+	ErrorOr<VoidPtr> Process::New(SizeT sz, SizeT pad_amount)
 	{
 #ifdef __NE_VIRTUAL_MEMORY_SUPPORT__
 		auto vm_register = hal_read_cr3();
@@ -159,7 +159,7 @@ namespace Kernel
 	/// @brief Gets the name of the current process.
 	/***********************************************************************************/
 
-	const Char* UserProcess::GetName() noexcept
+	const Char* Process::GetName() noexcept
 	{
 		return this->Name;
 	}
@@ -168,13 +168,13 @@ namespace Kernel
 	/// @brief Gets the owner of the process.
 	/***********************************************************************************/
 
-	const User* UserProcess::GetOwner() noexcept
+	const User* Process::GetOwner() noexcept
 	{
 		return this->Owner;
 	}
 
-	/// @brief UserProcess status getter.
-	const ProcessStatusKind& UserProcess::GetStatus() noexcept
+	/// @brief Process status getter.
+	const ProcessStatusKind& Process::GetStatus() noexcept
 	{
 		return this->Status;
 	}
@@ -185,7 +185,7 @@ namespace Kernel
 	*/
 	/***********************************************************************************/
 
-	const AffinityKind& UserProcess::GetAffinity() noexcept
+	const AffinityKind& Process::GetAffinity() noexcept
 	{
 		return this->Affinity;
 	}
@@ -197,7 +197,7 @@ namespace Kernel
 	*/
 	/***********************************************************************************/
 
-	Void UserProcess::Exit(const Int32& exit_code)
+	Void Process::Exit(const Int32& exit_code)
 	{
 		this->Status		= exit_code > 0 ? ProcessStatusKind::kKilled : ProcessStatusKind::kFrozen;
 		this->fLastExitCode = exit_code;
@@ -294,7 +294,7 @@ namespace Kernel
 
 		++this->mTeam.mProcessCount;
 
-		UserProcess& process = this->mTeam.mProcessList[pid];
+		Process& process = this->mTeam.mProcessList[pid];
 
 		process.Image.fCode = code;
 		process.Image.fBlob = image;
@@ -336,7 +336,7 @@ namespace Kernel
 		// React according to process kind.
 		switch (process.Kind)
 		{
-		case UserProcess::kExectuableDylibKind: {
+		case Process::kExectuableDylibKind: {
 			process.DylibDelegate = rtl_init_dylib(process);
 			MUST_PASS(process.DylibDelegate);
 			break;
@@ -472,7 +472,7 @@ namespace Kernel
 
 	/// @brief Gets the current scheduled team.
 	/// @return
-	UserProcessTeam& UserProcessScheduler::CurrentTeam()
+	ProcessTeam& UserProcessScheduler::CurrentTeam()
 	{
 		return mTeam;
 	}
@@ -481,13 +481,13 @@ namespace Kernel
 
 	/// @brief Gets current running process.
 	/// @return
-	Ref<UserProcess>& UserProcessScheduler::CurrentProcess()
+	Ref<Process>& UserProcessScheduler::CurrentProcess()
 	{
 		return mTeam.AsRef();
 	}
 
 	/// @brief Current proccess id getter.
-	/// @return UserProcess ID integer.
+	/// @return Process ID integer.
 	ErrorOr<PID> UserProcessHelper::TheCurrentPID()
 	{
 		if (!kProcessScheduler.CurrentProcess())
@@ -501,7 +501,7 @@ 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 Process& process)
 	{
 		if (process.Status == ProcessStatusKind::kKilled ||
 			process.Status == ProcessStatusKind::kFinished ||