Merge pull request #17 from amlel-el-mahrouss/dev

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

19 files changed, 91 insertions, 104 deletions

diff --git a/dev/kernel/FirmwareKit/GPT.h b/dev/kernel/FirmwareKit/GPT.h
index 99c9f9c8..c903f3ab 100644
--- a/dev/kernel/FirmwareKit/GPT.h
+++ b/dev/kernel/FirmwareKit/GPT.h
@@ -10,6 +10,7 @@
 #include <FirmwareKit/EFI/EFI.h>
 
 #define kSectorSizeGPT (512U)
+#define kPartNameGPT (8U)
 
 namespace Kernel
 {
@@ -28,7 +29,7 @@ namespace Kernel
 
 	struct PACKED GPT_PARTITION_TABLE final
 	{
-		Char	 PartitionName[8];
+		Char	 PartitionName[kPartNameGPT];
 		UInt32	 Revision;
 		UInt32	 HeaderSize;
 		UInt32	 ChecksumCRC32;
diff --git a/dev/kernel/HALKit/AMD64/HalKernelMain.cc b/dev/kernel/HALKit/AMD64/HalKernelMain.cc
index cc346b5c..cc3c8e93 100644
--- a/dev/kernel/HALKit/AMD64/HalKernelMain.cc
+++ b/dev/kernel/HALKit/AMD64/HalKernelMain.cc
@@ -22,7 +22,7 @@ STATIC Kernel::Void hal_init_scheduler_team()
 {
 	for (Kernel::SizeT i = 0U; i < Kernel::UserProcessScheduler::The().CurrentTeam().AsArray().Count(); ++i)
 	{
-		Kernel::UserProcessScheduler::The().CurrentTeam().AsArray()[i]		  = Kernel::UserProcess();
+		Kernel::UserProcessScheduler::The().CurrentTeam().AsArray()[i]		  = Kernel::Process();
 		Kernel::UserProcessScheduler::The().CurrentTeam().AsArray()[i].Status = Kernel::ProcessStatusKind::kKilled;
 	}
 }
diff --git a/dev/kernel/HALKit/AMD64/HalSchedulerCorePrimitivesAMD64.cc b/dev/kernel/HALKit/AMD64/HalSchedulerCorePrimitivesAMD64.cc
index dea3b3d4..ba5710e3 100644
--- a/dev/kernel/HALKit/AMD64/HalSchedulerCorePrimitivesAMD64.cc
+++ b/dev/kernel/HALKit/AMD64/HalSchedulerCorePrimitivesAMD64.cc
@@ -14,7 +14,7 @@ namespace Kernel
 	/// @param
 	/***********************************************************************************/
 
-	EXTERN_C Void __zka_pure_call(UserProcess* process)
+	EXTERN_C Void __zka_pure_call(Process* process)
 	{
 		if (process)
 			process->Crash();
diff --git a/dev/kernel/HALKit/AMD64/Storage/AHCI+Generic.cc b/dev/kernel/HALKit/AMD64/Storage/AHCI+Generic.cc
index f0893e2d..728b20ed 100644
--- a/dev/kernel/HALKit/AMD64/Storage/AHCI+Generic.cc
+++ b/dev/kernel/HALKit/AMD64/Storage/AHCI+Generic.cc
@@ -66,22 +66,6 @@ STATIC Int32 drv_find_cmd_slot_ahci(HbaPort* port) noexcept;
 
 STATIC Void drv_compute_disk_ahci() noexcept;
 
-namespace AHCI::Detail
-{
-	template <typename RetType>
-	STATIC RetType* ahci_align_address(RetType* address, Int32 alignement)
-	{
-		if (!address)
-			return nullptr;
-
-		UIntPtr addr = (UIntPtr)address;
-
-		UIntPtr aligned_addr = (addr + alignement - 1) & (~alignement - 1);
-
-		return (RetType*)aligned_addr;
-	}
-} // namespace AHCI::Detail
-
 STATIC Void drv_compute_disk_ahci() noexcept
 {
 	kSATASectorCount = 0UL;
@@ -90,18 +74,18 @@ STATIC Void drv_compute_disk_ahci() noexcept
 	const UInt16 kSzIdent = 512;
 
 	/// Push it to the stack
-	UInt16* identify_data = AHCI::Detail::ahci_align_address<UInt16>(new UInt16[kSzIdent], kib_cast(1));
+	UInt16* identify_data = new UInt16[kSzIdent];
 
 	/// Send AHCI command for identification.
 	drv_std_input_output_ahci<NO, YES, YES>(0, (UInt8*)identify_data, kAHCISectorSize, kSzIdent);
 
 	/// Extract 48-bit LBA.
-
 	UInt64 lba48_sectors = 0;
 	lba48_sectors |= (UInt64)identify_data[100];
 	lba48_sectors |= (UInt64)identify_data[101] << 16;
 	lba48_sectors |= (UInt64)identify_data[102] << 32;
 
+	/// Now verify if lba48
 	if (lba48_sectors == 0)
 		kSATASectorCount = (identify_data[61] << 16) | identify_data[60];
 	else
diff --git a/dev/kernel/HALKit/ARM64/HalSchedulerCorePrimitivesARM64.cc b/dev/kernel/HALKit/ARM64/HalSchedulerCorePrimitivesARM64.cc
index 2f5c92e5..594ee76e 100644
--- a/dev/kernel/HALKit/ARM64/HalSchedulerCorePrimitivesARM64.cc
+++ b/dev/kernel/HALKit/ARM64/HalSchedulerCorePrimitivesARM64.cc
@@ -14,7 +14,7 @@ namespace Kernel
 	/// @param void

 	/***********************************************************************************/

 

-	EXTERN_C Void __zka_pure_call(UserProcess* process)

+	EXTERN_C Void __zka_pure_call(Process* process)

 	{

 		if (process)

 			process->Crash();

diff --git a/dev/kernel/KernelKit/BinaryMutex.h b/dev/kernel/KernelKit/BinaryMutex.h
index ec1e355d..675396fd 100644
--- a/dev/kernel/KernelKit/BinaryMutex.h
+++ b/dev/kernel/KernelKit/BinaryMutex.h
@@ -12,9 +12,9 @@
 
 namespace Kernel
 {
-	class UserProcess;
+	class Process;
 
-	typedef UserProcess& UserProcessRef;
+	typedef Process& UserProcessRef;
 
 	/// @brief Access control class, which locks a task until one is done.
 	class BinaryMutex final
@@ -31,8 +31,8 @@ namespace Kernel
 		BOOL WaitForProcess(const Int16& sec) noexcept;
 
 	public:
-		bool Lock(UserProcess& process);
-		bool LockOrWait(UserProcess& process, TimerInterface* timer);
+		bool Lock(Process& process);
+		bool LockOrWait(Process& process, TimerInterface* timer);
 
 	public:
 		NE_COPY_DEFAULT(BinaryMutex)
diff --git a/dev/kernel/KernelKit/Defines.h b/dev/kernel/KernelKit/Defines.h
index ca258f58..1356f340 100644
--- a/dev/kernel/KernelKit/Defines.h
+++ b/dev/kernel/KernelKit/Defines.h
@@ -13,4 +13,4 @@
 
 class UserProcessScheduler;
 class IDylibObject;
-class UserProcess;
+class Process;
diff --git a/dev/kernel/KernelKit/DeviceMgr.h b/dev/kernel/KernelKit/DeviceMgr.h
index 64949162..fcafa7a5 100644
--- a/dev/kernel/KernelKit/DeviceMgr.h
+++ b/dev/kernel/KernelKit/DeviceMgr.h
@@ -52,13 +52,13 @@ namespace Kernel
 		IDeviceObject(const IDeviceObject<T>&)			  = default;
 
 	public:
-		virtual IDeviceObject<T>& operator<<(T Data) [[maybe_unused]]
+		virtual IDeviceObject<T>& operator<<(T Data) 
 		{
 			fOut(this, Data);
 			return *this;
 		}
 
-		virtual IDeviceObject<T>& operator>>(T Data) [[maybe_unused]]
+		virtual IDeviceObject<T>& operator>>(T Data) 
 		{
 			fIn(this, Data);
 			return *this;
@@ -133,6 +133,7 @@ namespace Kernel
 		kDeviceTypeSCSI,
 		kDeviceTypeAHCI,
 		kDeviceTypeMBCI,
+		kDeviceTypeATA,
 		kDeviceTypeUSB,
 		kDeviceTypeMediaCtrl, // MM controller
 		kDeviceTypeCount,
diff --git a/dev/kernel/KernelKit/IPEFDylibObject.h b/dev/kernel/KernelKit/IPEFDylibObject.h
index 4769f0f9..f1edc1d5 100644
--- a/dev/kernel/KernelKit/IPEFDylibObject.h
+++ b/dev/kernel/KernelKit/IPEFDylibObject.h
@@ -99,8 +99,8 @@ namespace Kernel
 
 	typedef IPEFDylibObject* IDylibRef;
 
-	EXTERN_C IDylibRef rtl_init_dylib(UserProcess& header);
-	EXTERN_C Void	   rtl_fini_dylib(UserProcess& header, IDylibRef lib, Bool* successful);
+	EXTERN_C IDylibRef rtl_init_dylib(Process& header);
+	EXTERN_C Void	   rtl_fini_dylib(Process& header, IDylibRef lib, Bool* successful);
 } // namespace Kernel
 
 #endif /* ifndef __KERNELKIT_SHARED_OBJECT_H__ */
diff --git a/dev/kernel/KernelKit/PEF.h b/dev/kernel/KernelKit/PEF.h
index 41abe3fd..1cfbfa54 100644
--- a/dev/kernel/KernelKit/PEF.h
+++ b/dev/kernel/KernelKit/PEF.h
@@ -21,10 +21,10 @@
 #define kPefMagic	 "Joy!"
 #define kPefMagicFat "yoJ!"
 
-#define kPefMagicLen 5
+#define kPefMagicLen (5)
 
-#define kPefVersion 3
-#define kPefNameLen 256U
+#define kPefVersion (3)
+#define kPefNameLen (256U)
 
 /* not mandatory, only for non fork based filesystems. */
 #define kPefExt		  ".exec"
diff --git a/dev/kernel/KernelKit/ProcessScheduler.h b/dev/kernel/KernelKit/ProcessScheduler.h
index 631bac6e..db6f9aed 100644
--- a/dev/kernel/KernelKit/ProcessScheduler.h
+++ b/dev/kernel/KernelKit/ProcessScheduler.h
@@ -7,6 +7,7 @@
 #ifndef INC_PROCESS_SCHEDULER_H
 #define INC_PROCESS_SCHEDULER_H
 
+/// @file ProcessScheduler.h
 /// @brief Process scheduler code and definitions.
 /// @author Amlal El Mahrouss (amlal@nekernel.org)
 
@@ -16,7 +17,7 @@
 #include <NewKit/MutableArray.h>
 
 #define kSchedMinMicroTime		  (AffinityKind::kStandard)
-#define kSchedInvalidPID		  ((PID)~0)
+#define kSchedInvalidPID		  (-1)
 #define kSchedProcessLimitPerTeam (32U)
 
 #define kSchedMaxMemoryLimit gib_cast(128) /* max physical memory limit */
@@ -33,8 +34,8 @@ namespace Kernel
 	//! @brief Forward declarations.
 
 	class IDylibObject;
-	class UserProcess;
-	class UserProcessTeam;
+	class Process;
+	class ProcessTeam;
 	class UserProcessScheduler;
 	class UserProcessHelper;
 
@@ -141,9 +142,9 @@ namespace Kernel
 	/***********************************************************************************/
 	using ImagePtr = VoidPtr;
 
-	struct UserProcessImage final
+	struct ProcessImage final
 	{
-		explicit UserProcessImage() = default;
+		explicit ProcessImage() = default;
 
 		ImagePtr fCode;
 		ImagePtr fBlob;
@@ -160,17 +161,17 @@ namespace Kernel
 	};
 
 	/***********************************************************************************/
-	/// @name UserProcess
-	/// @brief User process class, holds information about the running process/thread.
+	/// @name Process
+	/// @brief Process class, holds information about the running process/thread.
 	/***********************************************************************************/
-	class UserProcess final
+	class Process final
 	{
 	public:
-		explicit UserProcess();
-		~UserProcess();
+		explicit Process();
+		~Process();
 
 	public:
-		NE_COPY_DEFAULT(UserProcess)
+		NE_COPY_DEFAULT(Process)
 
 	public:
 		Char			   Name[kSchedNameLen] = {"Process"};
@@ -180,7 +181,7 @@ namespace Kernel
 		AffinityKind	   Affinity{AffinityKind::kStandard};
 		ProcessStatusKind  Status{ProcessStatusKind::kFinished};
 		UInt8*			   StackReserve{nullptr};
-		UserProcessImage   Image{};
+		ProcessImage   Image{};
 		SizeT			   StackSize{kSchedMaxStackSz};
 		IDylibObject*	   DylibDelegate{nullptr};
 		SizeT			   MemoryCursor{0UL};
@@ -197,16 +198,16 @@ namespace Kernel
 			struct ProcessMemoryHeapList* MemoryNext{nullptr};
 		};
 
-		struct UserProcessSignal final
+		struct ProcessSignal final
 		{
 			UIntPtr			  SignalArg;
 			ProcessStatusKind PreviousStatus;
 			UIntPtr			  SignalID;
 		};
 
-		UserProcessSignal	   ProcessSignal;
+		ProcessSignal	   ProcessSignal;
 		ProcessMemoryHeapList* ProcessMemoryHeap{nullptr};
-		UserProcessTeam*	   ProcessParentTeam;
+		ProcessTeam*	   ProcessParentTeam;
 
 		VoidPtr VMRegister{0UL};
 
@@ -292,28 +293,28 @@ namespace Kernel
 
 	/// \brief Processs Team (contains multiple processes inside it.)
 	/// Equivalent to a process batch
-	class UserProcessTeam final
+	class ProcessTeam final
 	{
 	public:
-		explicit UserProcessTeam();
-		~UserProcessTeam() = default;
+		explicit ProcessTeam();
+		~ProcessTeam() = default;
 
-		NE_COPY_DEFAULT(UserProcessTeam)
+		NE_COPY_DEFAULT(ProcessTeam)
 
-		Array<UserProcess, kSchedProcessLimitPerTeam>& AsArray();
-		Ref<UserProcess>&							   AsRef();
+		Array<Process, kSchedProcessLimitPerTeam>& AsArray();
+		Ref<Process>&							   AsRef();
 		ProcessID&									   Id() noexcept;
 
 	public:
-		Array<UserProcess, kSchedProcessLimitPerTeam> mProcessList;
-		Ref<UserProcess>							  mCurrentProcess;
+		Array<Process, kSchedProcessLimitPerTeam> mProcessList;
+		Ref<Process>							  mCurrentProcess;
 		ProcessID									  mTeamId{0};
 		ProcessID									  mProcessCount{0};
 	};
 
-	typedef Array<UserProcess, kSchedProcessLimitPerTeam> UserThreadArray;
+	typedef Array<Process, kSchedProcessLimitPerTeam> UserThreadArray;
 
-	using UserProcessRef = UserProcess&;
+	using UserProcessRef = Process&;
 
 	/***********************************************************************************/
 	/// @brief Process scheduler class.
@@ -333,7 +334,7 @@ namespace Kernel
 		bool operator!();
 
 	public:
-		UserProcessTeam& CurrentTeam();
+		ProcessTeam& CurrentTeam();
 
 	public:
 		ProcessID  Spawn(const Char* name, VoidPtr code, VoidPtr image);
@@ -344,19 +345,19 @@ namespace Kernel
 		Bool HasMP() override;
 
 	public:
-		Ref<UserProcess>& CurrentProcess();
+		Ref<Process>& CurrentProcess();
 		SizeT		  Run() noexcept;
 
 	public:
 		STATIC UserProcessScheduler& The();
 
 	private:
-		UserProcessTeam mTeam{};
+		ProcessTeam mTeam{};
 	};
 
 	/***********************************************************************************/
 	/**
-	 * \brief UserProcess helper class, which contains needed utilities for the scheduler.
+	 * \brief Process helper class, which contains needed utilities for the scheduler.
 	 */
 	/***********************************************************************************/
 
@@ -364,7 +365,7 @@ namespace Kernel
 	{
 	public:
 		STATIC Bool Switch(VoidPtr image_ptr, UInt8* stack_ptr, HAL::StackFramePtr frame_ptr, PID new_pid);
-		STATIC Bool CanBeScheduled(const UserProcess& process);
+		STATIC Bool CanBeScheduled(const Process& process);
 		STATIC ErrorOr<PID> TheCurrentPID();
 		STATIC SizeT		StartScheduling();
 	};
diff --git a/dev/kernel/KernelKit/UserProcessScheduler.inl b/dev/kernel/KernelKit/UserProcessScheduler.inl
index 39e2aaf0..d89d9aa1 100644
--- a/dev/kernel/KernelKit/UserProcessScheduler.inl
+++ b/dev/kernel/KernelKit/UserProcessScheduler.inl
@@ -17,7 +17,7 @@ namespace Kernel
 	/***********************************************************************************/
 
 	template <typename T>
-	Boolean UserProcess::Delete(ErrorOr<T*> ptr)
+	Boolean Process::Delete(ErrorOr<T*> ptr)
 	{
 		if (!ptr)
 			return No;
diff --git a/dev/kernel/NetworkKit/IPC.h b/dev/kernel/NetworkKit/IPC.h
index 6de306b2..6304740c 100644
--- a/dev/kernel/NetworkKit/IPC.h
+++ b/dev/kernel/NetworkKit/IPC.h
@@ -34,7 +34,7 @@ namespace Kernel
 	struct PACKED IPC_ADDR final
 	{
 		UInt64 UserProcessID;
-		UInt64 UserProcessTeam;
+		UInt64 ProcessTeam;
 
 		////////////////////////////////////
 		// some operators.
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 ||