dev, kernel: scheduler and disk swap refactors.

Details:

	- Reworked SCSI groundwork to prepare for a Generic SCSI driver.
	- Refatored scheduler's code with the new coding style for
	  structs.
	- Add Leak and LeakBlob inside PROCESS_IMAGE struct.

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

25 files changed, 210 insertions, 166 deletions

diff --git a/dev/kernel/FirmwareKit/EPM.h b/dev/kernel/FirmwareKit/EPM.h
index 6db82506..fe228127 100644
--- a/dev/kernel/FirmwareKit/EPM.h
+++ b/dev/kernel/FirmwareKit/EPM.h
@@ -81,7 +81,7 @@ typedef struct EPM_GUID
 struct PACKED EPM_PART_BLOCK
 {
 	Kernel::Char  Magic[kEPMMagicLength] = {0};
-	Kernel::Char  Name[kEPMNameLength] = {0};
+	Kernel::Char  Name[kEPMNameLength]	 = {0};
 	EPM_GUID	  Guid;
 	Kernel::Int32 Version;
 	Kernel::Int64 NumBlocks;
@@ -109,10 +109,9 @@ enum
 };
 
 inline EPM_GUID kEPMNilGuid = {
-    0x0U,              
-    0x0U,                  
-    0x0U,                  
-    { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 }
-};
+	0x0U,
+	0x0U,
+	0x0U,
+	{0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}};
 
 #endif // ifndef FIRMWAREKIT_EPM_H
diff --git a/dev/kernel/FirmwareKit/GPT.h b/dev/kernel/FirmwareKit/GPT.h
index 4be1fed2..55356121 100644
--- a/dev/kernel/FirmwareKit/GPT.h
+++ b/dev/kernel/FirmwareKit/GPT.h
@@ -22,30 +22,30 @@ namespace Kernel
 
 	struct PACKED GPT_PARTITION_TABLE final
 	{
-		Char	 Signature[kMagicLenGPT];
-		UInt32	 Revision;
-		UInt32	 HeaderSize;
-		UInt32	 CRC32;
-		UInt32	 Reserved1;
-		UInt64	 LBAHeader;
-		UInt64	 LBAAltHeader;
-		UInt64	 FirstGPTEntry;
-		UInt64	 LastGPTEntry;
+		Char	Signature[kMagicLenGPT];
+		UInt32	Revision;
+		UInt32	HeaderSize;
+		UInt32	CRC32;
+		UInt32	Reserved1;
+		UInt64	LBAHeader;
+		UInt64	LBAAltHeader;
+		UInt64	FirstGPTEntry;
+		UInt64	LastGPTEntry;
 		EfiGUID Guid;
-		UInt64	 StartingLBA;
-		UInt32	 NumPartitionEntries;
-		UInt32	 SizeOfEntries;
-		UInt32	 CRC32PartEntry;
-		UInt8	 Reserved2[kSectorAlignGPT_PartTbl];
+		UInt64	StartingLBA;
+		UInt32	NumPartitionEntries;
+		UInt32	SizeOfEntries;
+		UInt32	CRC32PartEntry;
+		UInt8	Reserved2[kSectorAlignGPT_PartTbl];
 	};
 
 	struct PACKED GPT_PARTITION_ENTRY
 	{
 		EfiGUID PartitionTypeGUID;
 		EfiGUID UniquePartitionGUID;
-		UInt64	 StartLBA;
-		UInt64	 EndLBA;
-		UInt64	 Attributes;
-		UInt8	 Name[kSectorAlignGPT_PartEntry];
+		UInt64	StartLBA;
+		UInt64	EndLBA;
+		UInt64	Attributes;
+		UInt8	Name[kSectorAlignGPT_PartEntry];
 	};
 } // namespace Kernel
diff --git a/dev/kernel/FirmwareKit/VEPM.h b/dev/kernel/FirmwareKit/VEPM.h
index 2b95e12d..5830a879 100644
--- a/dev/kernel/FirmwareKit/VEPM.h
+++ b/dev/kernel/FirmwareKit/VEPM.h
@@ -22,20 +22,18 @@
 /// @brief VEPM GUID.
 /// @note This is the GUID used to identify a VEPM partition.
 inline EPM_GUID kVEPMGuidEPM = {
-    0x9a1b3f2e,              
-    0x4c3f,                  
-    0x4d52,                  
-    { 0xa7, 0x83, 0x9c, 0x21, 0x7b, 0x5e, 0x4d, 0xac }
-};
+	0x9a1b3f2e,
+	0x4c3f,
+	0x4d52,
+	{0xa7, 0x83, 0x9c, 0x21, 0x7b, 0x5e, 0x4d, 0xac}};
 
 /// @brief VEPM GUID.
 /// @note This is the GUID used to identify a VEPM partition (EFI version)
 inline EfiGUID kVEPMGuidEFI = {
-    0x9a1b3f2e,              
-    0x4c3f,                  
-    0x4d52,                  
-    { 0xa7, 0x83, 0x9c, 0x21, 0x7b, 0x5e, 0x4d, 0xac }
-};
+	0x9a1b3f2e,
+	0x4c3f,
+	0x4d52,
+	{0xa7, 0x83, 0x9c, 0x21, 0x7b, 0x5e, 0x4d, 0xac}};
 
 #define kVEPMGuidStr "9a1b3f2e-4c3f-4d52-a783-9c217b5e4dac"
 #endif // __NE_VEPM__
diff --git a/dev/kernel/HALKit/AMD64/HalCoreInterruptHandlerAMD64.cc b/dev/kernel/HALKit/AMD64/HalCoreInterruptHandlerAMD64.cc
index 46775a7f..7114f9f7 100644
--- a/dev/kernel/HALKit/AMD64/HalCoreInterruptHandlerAMD64.cc
+++ b/dev/kernel/HALKit/AMD64/HalCoreInterruptHandlerAMD64.cc
@@ -24,9 +24,9 @@ EXTERN_C void idt_handle_gpf(Kernel::UIntPtr rsp)
 
 	Kernel::kout << "Kernel: General Protection Fault.\r";
 
-	process.Leak().ProcessSignal.SignalArg		= rsp;
-	process.Leak().ProcessSignal.SignalID		= SIGKILL;
-	process.Leak().ProcessSignal.PreviousStatus = process.Leak().Status;
+	process.Leak().Signal.SignalArg		 = rsp;
+	process.Leak().Signal.SignalID		 = SIGKILL;
+	process.Leak().Signal.PreviousStatus = process.Leak().Status;
 
 	Kernel::kout << "Kernel: SIGKILL status.\r";
 
@@ -49,9 +49,9 @@ EXTERN_C void idt_handle_pf(Kernel::UIntPtr rsp)
 	Kernel::kout << "Kernel: Page Fault.\r";
 	Kernel::kout << "Kernel: SIGKILL\r";
 
-	process.Leak().ProcessSignal.SignalArg		= rsp;
-	process.Leak().ProcessSignal.SignalID		= SIGKILL;
-	process.Leak().ProcessSignal.PreviousStatus = process.Leak().Status;
+	process.Leak().Signal.SignalArg		 = rsp;
+	process.Leak().Signal.SignalID		 = SIGKILL;
+	process.Leak().Signal.PreviousStatus = process.Leak().Status;
 
 	process.Leak().Status = Kernel::ProcessStatusKind::kKilled;
 
@@ -99,9 +99,9 @@ EXTERN_C void idt_handle_math(Kernel::UIntPtr rsp)
 
 	Kernel::kout << "Kernel: Math error (division by zero?).\r";
 
-	process.Leak().ProcessSignal.SignalArg		= rsp;
-	process.Leak().ProcessSignal.SignalID		= SIGKILL;
-	process.Leak().ProcessSignal.PreviousStatus = process.Leak().Status;
+	process.Leak().Signal.SignalArg		 = rsp;
+	process.Leak().Signal.SignalID		 = SIGKILL;
+	process.Leak().Signal.PreviousStatus = process.Leak().Status;
 
 	Kernel::kout << "Kernel: SIGKILL status.\r";
 
@@ -123,9 +123,9 @@ EXTERN_C void idt_handle_generic(Kernel::UIntPtr rsp)
 
 	Kernel::kout << "Kernel: Generic Process Fault.\r";
 
-	process.Leak().ProcessSignal.SignalArg		= rsp;
-	process.Leak().ProcessSignal.SignalID		= SIGKILL;
-	process.Leak().ProcessSignal.PreviousStatus = process.Leak().Status;
+	process.Leak().Signal.SignalArg		 = rsp;
+	process.Leak().Signal.SignalID		 = SIGKILL;
+	process.Leak().Signal.PreviousStatus = process.Leak().Status;
 
 	Kernel::kout << "Kernel: SIGKILL status.\r";
 
@@ -151,10 +151,10 @@ EXTERN_C Kernel::Void idt_handle_breakpoint(Kernel::UIntPtr rip)
 	(void)(Kernel::kout << "Kernel: Process RIP: " << Kernel::hex_number(rip) << Kernel::kendl);
 	Kernel::kout << "Kernel: SIGTRAP\r";
 
-	process.Leak().ProcessSignal.SignalArg = rip;
-	process.Leak().ProcessSignal.SignalID  = SIGTRAP;
+	process.Leak().Signal.SignalArg = rip;
+	process.Leak().Signal.SignalID	= SIGTRAP;
 
-	process.Leak().ProcessSignal.PreviousStatus = process.Leak().Status;
+	process.Leak().Signal.PreviousStatus = process.Leak().Status;
 
 	Kernel::kout << "Kernel: SIGTRAP status.\r";
 
@@ -174,9 +174,9 @@ EXTERN_C void idt_handle_ud(Kernel::UIntPtr rsp)
 
 	Kernel::kout << "Kernel: Undefined Opcode.\r";
 
-	process.Leak().ProcessSignal.SignalArg		= rsp;
-	process.Leak().ProcessSignal.SignalID		= SIGKILL;
-	process.Leak().ProcessSignal.PreviousStatus = process.Leak().Status;
+	process.Leak().Signal.SignalArg		 = rsp;
+	process.Leak().Signal.SignalID		 = SIGKILL;
+	process.Leak().Signal.PreviousStatus = process.Leak().Status;
 
 	Kernel::kout << "Kernel: SIGKILL status.\r";
 
diff --git a/dev/kernel/HALKit/AMD64/HalKernelMain.cc b/dev/kernel/HALKit/AMD64/HalKernelMain.cc
index c2be925a..20994d9b 100644
--- a/dev/kernel/HALKit/AMD64/HalKernelMain.cc
+++ b/dev/kernel/HALKit/AMD64/HalKernelMain.cc
@@ -27,7 +27,7 @@ STATIC Kernel::Void hal_pre_init_scheduler()
 {
 	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::USER_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 c2739f27..56ed4b34 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(USER_PROCESS* process)
 	{
 		if (process)
 			process->Crash();
diff --git a/dev/kernel/HALKit/AMD64/Storage/SCSI+Generic.cc b/dev/kernel/HALKit/AMD64/Storage/SCSI+Generic.cc
new file mode 100644
index 00000000..cb387e73
--- /dev/null
+++ b/dev/kernel/HALKit/AMD64/Storage/SCSI+Generic.cc
@@ -0,0 +1,13 @@
+/* -------------------------------------------
+
+	Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
+
+------------------------------------------- */
+
+#include <modules/SCSI/SCSI.h>
+
+using namespace Kernel;
+
+///! @brief ATAPI SCSI packet.
+const ATTRIBUTE(unused) scsi_packet_type_12 kCDRomPacketTemplate = {0x43, 0, 1, 0, 0, 0,
+																	0, 12, 0x40, 0, 0};
diff --git a/dev/kernel/HALKit/ARM64/HalSchedulerCorePrimitivesARM64.cc b/dev/kernel/HALKit/ARM64/HalSchedulerCorePrimitivesARM64.cc
index 2f5c92e5..84aae986 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(USER_PROCESS* process)

 	{

 		if (process)

 			process->Crash();

diff --git a/dev/kernel/HALKit/ARM64/Storage/SCSI+Generic.cc b/dev/kernel/HALKit/ARM64/Storage/SCSI+Generic.cc
new file mode 100644
index 00000000..cb387e73
--- /dev/null
+++ b/dev/kernel/HALKit/ARM64/Storage/SCSI+Generic.cc
@@ -0,0 +1,13 @@
+/* -------------------------------------------
+
+	Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
+
+------------------------------------------- */
+
+#include <modules/SCSI/SCSI.h>
+
+using namespace Kernel;
+
+///! @brief ATAPI SCSI packet.
+const ATTRIBUTE(unused) scsi_packet_type_12 kCDRomPacketTemplate = {0x43, 0, 1, 0, 0, 0,
+																	0, 12, 0x40, 0, 0};
diff --git a/dev/kernel/KernelKit/BinaryMutex.h b/dev/kernel/KernelKit/BinaryMutex.h
index ec1e355d..660d2e71 100644
--- a/dev/kernel/KernelKit/BinaryMutex.h
+++ b/dev/kernel/KernelKit/BinaryMutex.h
@@ -12,9 +12,7 @@
 
 namespace Kernel
 {
-	class UserProcess;
-
-	typedef UserProcess& UserProcessRef;
+	class USER_PROCESS;
 
 	/// @brief Access control class, which locks a task until one is done.
 	class BinaryMutex final
@@ -31,13 +29,13 @@ namespace Kernel
 		BOOL WaitForProcess(const Int16& sec) noexcept;
 
 	public:
-		bool Lock(UserProcess& process);
-		bool LockOrWait(UserProcess& process, TimerInterface* timer);
+		bool Lock(USER_PROCESS& process);
+		bool LockOrWait(USER_PROCESS& process, TimerInterface* timer);
 
 	public:
 		NE_COPY_DEFAULT(BinaryMutex)
 
 	private:
-		UserProcessRef fLockingProcess;
+		USER_PROCESS fLockingProcess;
 	};
 } // namespace Kernel
diff --git a/dev/kernel/KernelKit/FileMgr.h b/dev/kernel/KernelKit/FileMgr.h
index e5f67080..f4acdae9 100644
--- a/dev/kernel/KernelKit/FileMgr.h
+++ b/dev/kernel/KernelKit/FileMgr.h
@@ -40,8 +40,8 @@
 #define kRestrictR	 "r"
 #define kRestrictRB	 "rb"
 #define kRestrictW	 "w"
-#define kRestrictWB	 "rw"
-#define kRestrictRWB "rwb"
+#define kRestrictWR	 "rw"
+#define kRestrictWRB "rwb"
 
 #define kRestrictMax (5U)
 
@@ -354,7 +354,7 @@ namespace Kernel
 				.fMappedTo = kFileMgrRestrictReadBinary,
 			},
 			{
-				.fRestrict = kRestrictRWB,
+				.fRestrict = kRestrictWRB,
 				.fMappedTo = kFileMgrRestrictReadWriteBinary,
 			},
 			{
@@ -362,7 +362,7 @@ namespace Kernel
 				.fMappedTo = kFileMgrRestrictWrite,
 			},
 			{
-				.fRestrict = kRestrictWB,
+				.fRestrict = kRestrictWR,
 				.fMappedTo = kFileMgrRestrictReadWrite,
 			}};
 
diff --git a/dev/kernel/KernelKit/IPEFDylibObject.h b/dev/kernel/KernelKit/IPEFDylibObject.h
index 4769f0f9..82f08932 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(USER_PROCESS& header);
+	EXTERN_C Void	   rtl_fini_dylib(USER_PROCESS& header, IDylibRef lib, Bool* successful);
 } // namespace Kernel
 
 #endif /* ifndef __KERNELKIT_SHARED_OBJECT_H__ */
diff --git a/dev/kernel/KernelKit/ProcessSchedulerCore.h b/dev/kernel/KernelKit/ProcessSchedulerCore.h
index 002e685e..ee90ed8b 100644
--- a/dev/kernel/KernelKit/ProcessSchedulerCore.h
+++ b/dev/kernel/KernelKit/ProcessSchedulerCore.h
@@ -7,11 +7,12 @@
 #pragma once
 
 #include <NewKit/Defines.h>
+#include <NewKit/ErrorOr.h>
 
 namespace Kernel
 {
-	class UserProcess;
-    class KernelProcess;
+	class USER_PROCESS;
+	class KERNEL_PROCESS;
 	class UserProcessTeam;
 
 	/***********************************************************************************/
@@ -117,9 +118,9 @@ namespace Kernel
 	/***********************************************************************************/
 	using ImagePtr = VoidPtr;
 
-	struct ProcessImage final
+	struct PROCESS_IMAGE final
 	{
-		explicit ProcessImage() = default;
+		explicit PROCESS_IMAGE() = default;
 
 		ImagePtr fCode;
 		ImagePtr fBlob;
@@ -133,5 +134,25 @@ namespace Kernel
 		{
 			return this->fBlob != nullptr;
 		}
+
+		ErrorOr<ImagePtr> Leak()
+		{
+			if (this->fCode)
+			{
+				return ErrorOr<ImagePtr>{this->fCode};
+			}
+
+			return ErrorOr<ImagePtr>{nullptr};
+		}
+
+		ErrorOr<ImagePtr> LeakBlob()
+		{
+			if (this->fBlob)
+			{
+				return ErrorOr<ImagePtr>{this->fBlob};
+			}
+
+			return ErrorOr<ImagePtr>{nullptr};
+		}
 	};
 } // namespace Kernel
diff --git a/dev/kernel/KernelKit/UserProcessScheduler.h b/dev/kernel/KernelKit/UserProcessScheduler.h
index 4ba4b779..6e1ca146 100644
--- a/dev/kernel/KernelKit/UserProcessScheduler.h
+++ b/dev/kernel/KernelKit/UserProcessScheduler.h
@@ -8,7 +8,7 @@
 #define INC_PROCESS_SCHEDULER_H
 
 /// @file UserProcessScheduler.h
-/// @brief User UserProcess scheduler code and definitions.
+/// @brief User USER_PROCESS scheduler code and definitions.
 /// @author Amlal El Mahrouss (amlal@nekernel.org)
 
 #include <ArchKit/ArchKit.h>
@@ -20,7 +20,7 @@
 #define kSchedMinMicroTime		  (AffinityKind::kStandard)
 #define kSchedInvalidPID		  (-1)
 #define kSchedProcessLimitPerTeam (32U)
-#define kSchedTeamCount (512U)
+#define kSchedTeamCount			  (512U)
 
 #define kSchedMaxMemoryLimit gib_cast(128) /* max physical memory limit */
 #define kSchedMaxStackSz	 mib_cast(8)   /* maximum stack size */
@@ -40,53 +40,53 @@ namespace Kernel
 	class UserProcessHelper;
 
 	/***********************************************************************************/
-	/// @name UserProcess
-	/// @brief UserProcess class, holds information about the running process/thread.
+	/// @name USER_PROCESS
+	/// @brief USER_PROCESS class, holds information about the running process/thread.
 	/***********************************************************************************/
-	class UserProcess final
+	class USER_PROCESS final
 	{
 	public:
-		explicit UserProcess();
-		~UserProcess();
+		explicit USER_PROCESS();
+		~USER_PROCESS();
 
 	public:
-		NE_COPY_DEFAULT(UserProcess)
+		NE_COPY_DEFAULT(USER_PROCESS)
 
 	public:
-		Char			   Name[kSchedNameLen] = {"UserProcess"};
+		Char			   Name[kSchedNameLen] = {"USER_PROCESS"};
 		ProcessSubsystem   SubSystem{ProcessSubsystem::kProcessSubsystemInvalid};
 		User*			   Owner{nullptr};
 		HAL::StackFramePtr StackFrame{nullptr};
 		AffinityKind	   Affinity{AffinityKind::kStandard};
 		ProcessStatusKind  Status{ProcessStatusKind::kFinished};
 		UInt8*			   StackReserve{nullptr};
-		ProcessImage	   Image{};
+		PROCESS_IMAGE	   Image{};
 		SizeT			   StackSize{kSchedMaxStackSz};
 		IDylibObject*	   DylibDelegate{nullptr};
 		SizeT			   MemoryCursor{0UL};
 		SizeT			   MemoryLimit{kSchedMaxMemoryLimit};
 		SizeT			   UsedMemory{0UL};
 
-		struct ProcessMemoryHeapList final
+		struct USER_HEAP_LIST final
 		{
 			VoidPtr MemoryEntry{nullptr};
 			SizeT	MemoryEntrySize{0UL};
 			SizeT	MemoryEntryPad{0UL};
 
-			struct ProcessMemoryHeapList* MemoryPrev{nullptr};
-			struct ProcessMemoryHeapList* MemoryNext{nullptr};
+			struct USER_HEAP_LIST* MemoryPrev{nullptr};
+			struct USER_HEAP_LIST* MemoryNext{nullptr};
 		};
 
-		struct ProcessSignal final
+		struct USER_PROCESS_SIGNAL final
 		{
 			UIntPtr			  SignalArg;
 			ProcessStatusKind PreviousStatus;
 			UIntPtr			  SignalID;
 		};
 
-		ProcessSignal		   ProcessSignal;
-		ProcessMemoryHeapList* ProcessMemoryHeap{nullptr};
-		UserProcessTeam*		   ProcessParentTeam;
+		USER_PROCESS_SIGNAL Signal;
+		USER_HEAP_LIST*		ProcessMemoryHeap{nullptr};
+		UserProcessTeam*	ProcessParentTeam;
 
 		VoidPtr VMRegister{0UL};
 
@@ -98,7 +98,7 @@ namespace Kernel
 			kExecutableKindCount,
 		};
 
-		ProcessTime PTime{0}; //! @brief UserProcess allocated tine.
+		ProcessTime PTime{0}; //! @brief USER_PROCESS allocated tine.
 
 		PID	  ProcessId{kSchedInvalidPID};
 		Int32 Kind{kExecutableKind};
@@ -170,6 +170,8 @@ namespace Kernel
 		friend UserProcessHelper;
 	};
 
+	typedef Array<USER_PROCESS, kSchedProcessLimitPerTeam> USER_PROCESS_ARRAY;
+
 	/// \brief Processs Team (contains multiple processes inside it.)
 	/// Equivalent to a process batch
 	class UserProcessTeam final
@@ -180,23 +182,19 @@ namespace Kernel
 
 		NE_COPY_DEFAULT(UserProcessTeam)
 
-		Array<UserProcess, kSchedProcessLimitPerTeam>& AsArray();
-		Ref<UserProcess>&							   AsRef();
-		ProcessID&								   Id() noexcept;
+		Array<USER_PROCESS, kSchedProcessLimitPerTeam>& AsArray();
+		Ref<USER_PROCESS>&								AsRef();
+		ProcessID&										Id() noexcept;
 
 	public:
-		Array<UserProcess, kSchedProcessLimitPerTeam> mProcessList;
-		Ref<UserProcess>							  mCurrentProcess;
-		ProcessID								  mTeamId{0};
-		ProcessID								  mProcessCount{0};
+		USER_PROCESS_ARRAY mProcessList;
+		Ref<USER_PROCESS>  mCurrentProcess;
+		ProcessID		   mTeamId{0};
+		ProcessID		   mProcessCount{0};
 	};
 
-	typedef Array<UserProcess, kSchedProcessLimitPerTeam> UserThreadArray;
-
-	using UserProcessRef = UserProcess&;
-
 	/***********************************************************************************/
-	/// @brief UserProcess scheduler class.
+	/// @brief USER_PROCESS scheduler class.
 	/// The main class which you call to schedule user processes.
 	/***********************************************************************************/
 	class UserProcessScheduler final : public ISchedulable
@@ -215,7 +213,7 @@ namespace Kernel
 
 	public:
 		UserProcessTeam& CurrentTeam();
-		BOOL		 SwitchTeam(UserProcessTeam& team);
+		BOOL			 SwitchTeam(UserProcessTeam& team);
 
 	public:
 		ProcessID Spawn(const Char* name, VoidPtr code, VoidPtr image);
@@ -226,8 +224,8 @@ namespace Kernel
 		Bool HasMP() override;
 
 	public:
-		Ref<UserProcess>& CurrentProcess();
-		SizeT		  Run() noexcept;
+		Ref<USER_PROCESS>& CurrentProcess();
+		SizeT			   Run() noexcept;
 
 	public:
 		STATIC UserProcessScheduler& The();
@@ -238,7 +236,7 @@ namespace Kernel
 
 	/***********************************************************************************/
 	/**
-	 * \brief UserProcess helper class, which contains needed utilities for the scheduler.
+	 * \brief USER_PROCESS helper class, which contains needed utilities for the scheduler.
 	 */
 	/***********************************************************************************/
 
@@ -246,7 +244,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 USER_PROCESS& process);
 		STATIC ErrorOr<PID> TheCurrentPID();
 		STATIC SizeT		StartScheduling();
 	};
diff --git a/dev/kernel/KernelKit/UserProcessScheduler.inl b/dev/kernel/KernelKit/UserProcessScheduler.inl
index 4179545c..a18af9c1 100644
--- a/dev/kernel/KernelKit/UserProcessScheduler.inl
+++ b/dev/kernel/KernelKit/UserProcessScheduler.inl
@@ -3,11 +3,11 @@
 	Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
 
 	FILE: UserProcessScheduler.inl
-	PURPOSE: Low level/Ring-3 UserProcess scheduler.
+	PURPOSE: Low level/Ring-3 USER_PROCESS scheduler.
 
 ------------------------------------------- */
 
-/// @brief UserProcess scheduler inline definitions.
+/// @brief USER_PROCESS scheduler inline definitions.
 /// @author Amlal El Mahrouss (amlal@nekernel.org)
 /// @date Tue Apr 22 22:01:07 CEST 2025
 
@@ -18,18 +18,18 @@ namespace Kernel
 	/***********************************************************************************/
 
 	template <typename T>
-	Boolean UserProcess::Delete(ErrorOr<T*> ptr)
+	Boolean USER_PROCESS::Delete(ErrorOr<T*> ptr)
 	{
 		if (!ptr)
 			return No;
 
 		if (!this->ProcessMemoryHeap)
 		{
-			kout << "UserProcess's heap is empty.\r";
+			kout << "USER_PROCESS's heap is empty.\r";
 			return No;
 		}
 
-		ProcessMemoryHeapList* entry = this->ProcessMemoryHeap;
+		USER_HEAP_LIST* entry = this->ProcessMemoryHeap;
 
 		while (entry != nullptr)
 		{
diff --git a/dev/kernel/StorageKit/SCSI.h b/dev/kernel/StorageKit/SCSI.h
index 655638f5..2a4c2393 100644
--- a/dev/kernel/StorageKit/SCSI.h
+++ b/dev/kernel/StorageKit/SCSI.h
@@ -8,4 +8,6 @@
 
 #include <modules/SCSI/SCSI.h>
 
-extern const scsi_packet_type<12> kCDRomPacketTemplate;
+namespace Kernel
+{
+} // namespace Kernel
\ No newline at end of file
diff --git a/dev/kernel/SwapKit/DiskSwap.h b/dev/kernel/SwapKit/DiskSwap.h
index 0e32eff5..78b1a896 100644
--- a/dev/kernel/SwapKit/DiskSwap.h
+++ b/dev/kernel/SwapKit/DiskSwap.h
@@ -9,9 +9,10 @@
 
 #include <NewKit/Defines.h>
 #include <CompilerKit/CompilerKit.h>
+#include <hint/CompilerHint.h>
 
 #define kSwapBlockMaxSize (mib_cast(16))
-#define kSwapPageFile	  "/boot/pagefile.sys"
+#define kSwapPageFilePath "/boot/pagefile.sys"
 
 /// @file SwapDisk.h
 /// @brief Virtual memory swap disk.
@@ -19,15 +20,18 @@
 namespace Kernel
 {
 	struct SWAP_DISK_HEADER;
+	class DiskSwapInterface;
 
 	/// @brief Virtual memory interface to swap memory chunks onto disk.
-	class SwapDiskInterface final
+	/// @note The class only supports the NeFS as of right now, as it is using forks to write data into disk.
+	class DiskSwapInterface final
 	{
 	public:
-		explicit SwapDiskInterface() = default;
-		~SwapDiskInterface()		 = default;
+		explicit DiskSwapInterface() = default;
+		~DiskSwapInterface()		 = default;
 
-		NE_COPY_DEFAULT(SwapDiskInterface)
+		NE_COPY_DELETE(DiskSwapInterface)
+		NE_MOVE_DELETE(DiskSwapInterface)
 
 	public:
 		/***********************************************************************************/
@@ -46,7 +50,7 @@ namespace Kernel
 		/// @param data the data packet length.
 		/// @return Whether the swap was fetched to disk, or not.
 		/***********************************************************************************/
-		SWAP_DISK_HEADER* Read(const Char* fork_name, SizeT fork_name_len, SizeT data_len);
+		_Output SWAP_DISK_HEADER* Read(const Char* fork_name, SizeT fork_name_len, SizeT data_len);
 	};
 
 	/// @brief Swap disk header, containing information about the held virtual memory.
diff --git a/dev/kernel/src/BinaryMutex.cc b/dev/kernel/src/BinaryMutex.cc
index ea6d5408..f86be37b 100644
--- a/dev/kernel/src/BinaryMutex.cc
+++ b/dev/kernel/src/BinaryMutex.cc
@@ -16,7 +16,7 @@ namespace Kernel
 	{
 		if (fLockingProcess)
 		{
-			fLockingProcess		   = UserProcess();
+			fLockingProcess		   = USER_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(USER_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(USER_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..df6ec253 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(USER_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(USER_PROCESS& process, IDylibRef dll_obj, BOOL* successful)
 {
 	MUST_PASS(successful);
 
diff --git a/dev/kernel/src/Network/IPCMsg.cc b/dev/kernel/src/Network/IPCMsg.cc
index 457776b3..06073214 100644
--- a/dev/kernel/src/Network/IPCMsg.cc
+++ b/dev/kernel/src/Network/IPCMsg.cc
@@ -90,11 +90,11 @@ namespace Kernel
 			(*pckt_in)->IpcEndianess  = static_cast<UInt8>(endianess);
 			(*pckt_in)->IpcPacketSize = sizeof(IPC_MSG);
 
-			(*pckt_in)->IpcTo.UserProcessID = 0;
-			(*pckt_in)->IpcTo.UserProcessTeam	= 0;
+			(*pckt_in)->IpcTo.UserProcessID	  = 0;
+			(*pckt_in)->IpcTo.UserProcessTeam = 0;
 
-			(*pckt_in)->IpcFrom.UserProcessID = 0;
-			(*pckt_in)->IpcFrom.UserProcessTeam	  = 0;
+			(*pckt_in)->IpcFrom.UserProcessID	= 0;
+			(*pckt_in)->IpcFrom.UserProcessTeam = 0;
 
 			return Yes;
 		}
diff --git a/dev/kernel/src/ProcessTeam.cc b/dev/kernel/src/ProcessTeam.cc
index 5ac3efeb..2fcc115e 100644
--- a/dev/kernel/src/ProcessTeam.cc
+++ b/dev/kernel/src/ProcessTeam.cc
@@ -17,7 +17,7 @@ namespace Kernel
 	{
 		for (SizeT i = 0U; i < this->mProcessList.Count(); ++i)
 		{
-			this->mProcessList[i]		 = UserProcess();
+			this->mProcessList[i]		 = USER_PROCESS();
 			this->mProcessList[i].PTime	 = 0;
 			this->mProcessList[i].Status = ProcessStatusKind::kKilled;
 		}
@@ -30,7 +30,7 @@ namespace Kernel
 	/// @return The list of process to schedule.
 	/***********************************************************************************/
 
-	Array<UserProcess, kSchedProcessLimitPerTeam>& UserProcessTeam::AsArray()
+	Array<USER_PROCESS, kSchedProcessLimitPerTeam>& UserProcessTeam::AsArray()
 	{
 		return this->mProcessList;
 	}
@@ -50,7 +50,7 @@ namespace Kernel
 	/// @return The current process header.
 	/***********************************************************************************/
 
-	Ref<UserProcess>& UserProcessTeam::AsRef()
+	Ref<USER_PROCESS>& UserProcessTeam::AsRef()
 	{
 		return this->mCurrentProcess;
 	}
diff --git a/dev/kernel/src/Storage/SCSIDeviceInterface.cc b/dev/kernel/src/Storage/SCSIDeviceInterface.cc
index 1b924227..85432822 100644
--- a/dev/kernel/src/Storage/SCSIDeviceInterface.cc
+++ b/dev/kernel/src/Storage/SCSIDeviceInterface.cc
@@ -6,6 +6,4 @@
 
 #include <StorageKit/SCSI.h>
 
-///! @brief ATAPI SCSI packet.
-const scsi_packet_type<12> kCDRomPacketTemplate = {0x43, 0, 1, 0, 0, 0,
-												   0, 12, 0x40, 0, 0};
+using namespace Kernel;
diff --git a/dev/kernel/src/Swap/DiskSwap.cc b/dev/kernel/src/Swap/DiskSwap.cc
index 1650a5af..a2703394 100644
--- a/dev/kernel/src/Swap/DiskSwap.cc
+++ b/dev/kernel/src/Swap/DiskSwap.cc
@@ -16,7 +16,7 @@ namespace Kernel
 	/// @param data the data packet.
 	/// @return Whether the swap was written to disk, or not.
 	/***********************************************************************************/
-	BOOL SwapDiskInterface::Write(const Char* fork_name, SizeT fork_name_len, SWAP_DISK_HEADER* data)
+	BOOL DiskSwapInterface::Write(const Char* fork_name, SizeT fork_name_len, SWAP_DISK_HEADER* data)
 	{
 		if (!fork_name || !fork_name_len)
 			return NO;
@@ -27,9 +27,9 @@ namespace Kernel
 		if (!data)
 			return NO;
 
-		FileStream file(kSwapPageFile, "wb");
+		FileStream file(kSwapPageFilePath, kRestrictWRB);
 
-		auto ret = file.Write(fork_name, data, sizeof(SWAP_DISK_HEADER) + data->fBlobSz);
+		ErrorOr<Int64> ret = file.Write(fork_name, data, sizeof(SWAP_DISK_HEADER) + data->fBlobSz);
 
 		if (ret.Error())
 			return NO;
@@ -44,7 +44,7 @@ namespace Kernel
 	/// @param data the data packet length.
 	/// @return Whether the swap was fetched to disk, or not.
 	/***********************************************************************************/
-	SWAP_DISK_HEADER* SwapDiskInterface::Read(const Char* fork_name, SizeT fork_name_len, SizeT data_len)
+	SWAP_DISK_HEADER* DiskSwapInterface::Read(const Char* fork_name, SizeT fork_name_len, SizeT data_len)
 	{
 		if (!fork_name || !fork_name_len)
 			return nullptr;
@@ -58,7 +58,7 @@ namespace Kernel
 		if (data_len == 0)
 			return nullptr;
 
-		FileStream file(kSwapPageFile, "rb");
+		FileStream file(kSwapPageFilePath, kRestrictRB);
 
 		VoidPtr blob = file.Read(fork_name, sizeof(SWAP_DISK_HEADER) + data_len);
 
diff --git a/dev/kernel/src/User.cc b/dev/kernel/src/User.cc
index d29ed112..421850f7 100644
--- a/dev/kernel/src/User.cc
+++ b/dev/kernel/src/User.cc
@@ -2,10 +2,10 @@
  *	========================================================
  *
  *  	NeKernel
- * 	Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
+ * 		Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
  *
- *	File: User.cc
- * 	Purpose: User class, used to provide authentication and security.
+ *		File: User.cc
+ * 		Purpose: User class, used to provide authentication and security.
  *
  * 	========================================================
  */
diff --git a/dev/kernel/src/UserProcessScheduler.cc b/dev/kernel/src/UserProcessScheduler.cc
index 5295c15a..68629bb2 100644
--- a/dev/kernel/src/UserProcessScheduler.cc
+++ b/dev/kernel/src/UserProcessScheduler.cc
@@ -3,7 +3,7 @@
 	Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
 
 	FILE: UserProcessScheduler.cc
-	PURPOSE: Low level/Ring-3 UserProcess scheduler.
+	PURPOSE: Low level/Ring-3 USER_PROCESS scheduler.
 
 ------------------------------------------- */
 
@@ -37,8 +37,8 @@ namespace Kernel
 
 	STATIC UserProcessScheduler kScheduler;
 
-	UserProcess::UserProcess()	= default;
-	UserProcess::~UserProcess() = default;
+	USER_PROCESS::USER_PROCESS()  = default;
+	USER_PROCESS::~USER_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 USER_PROCESS::Crash()
 	{
 		if (this->Status != ProcessStatusKind::kRunning)
 			return;
@@ -66,7 +66,7 @@ namespace Kernel
 	/// @brief boolean operator, check status.
 	/***********************************************************************************/
 
-	UserProcess::operator bool()
+	USER_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& USER_PROCESS::GetExitCode() noexcept
 	{
 		return this->fLastExitCode;
 	}
@@ -86,7 +86,7 @@ namespace Kernel
 	/// @brief Error code variable getter.
 	/***********************************************************************************/
 
-	Int32& UserProcess::GetLocalCode() noexcept
+	Int32& USER_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 USER_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> USER_PROCESS::New(SizeT sz, SizeT pad_amount)
 	{
 #ifdef __NE_VIRTUAL_MEMORY_SUPPORT__
 		auto vm_register = hal_read_cr3();
@@ -121,7 +121,7 @@ namespace Kernel
 
 		if (!this->ProcessMemoryHeap)
 		{
-			this->ProcessMemoryHeap = new ProcessMemoryHeapList();
+			this->ProcessMemoryHeap = new USER_HEAP_LIST();
 
 			this->ProcessMemoryHeap->MemoryEntryPad	 = pad_amount;
 			this->ProcessMemoryHeap->MemoryEntrySize = sz;
@@ -133,7 +133,7 @@ namespace Kernel
 		}
 		else
 		{
-			ProcessMemoryHeapList* entry = this->ProcessMemoryHeap;
+			USER_HEAP_LIST* entry = this->ProcessMemoryHeap;
 
 			while (entry)
 			{
@@ -143,7 +143,7 @@ namespace Kernel
 				entry = entry->MemoryNext;
 			}
 
-			entry->MemoryNext			   = new ProcessMemoryHeapList();
+			entry->MemoryNext			   = new USER_HEAP_LIST();
 			entry->MemoryNext->MemoryEntry = ptr;
 
 			entry->MemoryNext->MemoryPrev = entry;
@@ -159,7 +159,7 @@ namespace Kernel
 	/// @brief Gets the name of the current process.
 	/***********************************************************************************/
 
-	const Char* UserProcess::GetName() noexcept
+	const Char* USER_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* USER_PROCESS::GetOwner() noexcept
 	{
 		return this->Owner;
 	}
 
-	/// @brief UserProcess status getter.
-	const ProcessStatusKind& UserProcess::GetStatus() noexcept
+	/// @brief USER_PROCESS status getter.
+	const ProcessStatusKind& USER_PROCESS::GetStatus() noexcept
 	{
 		return this->Status;
 	}
@@ -185,7 +185,7 @@ namespace Kernel
 	*/
 	/***********************************************************************************/
 
-	const AffinityKind& UserProcess::GetAffinity() noexcept
+	const AffinityKind& USER_PROCESS::GetAffinity() noexcept
 	{
 		return this->Affinity;
 	}
@@ -197,7 +197,7 @@ namespace Kernel
 	*/
 	/***********************************************************************************/
 
-	Void UserProcess::Exit(const Int32& exit_code)
+	Void USER_PROCESS::Exit(const Int32& exit_code)
 	{
 		this->Status		= exit_code > 0 ? ProcessStatusKind::kKilled : ProcessStatusKind::kFrozen;
 		this->fLastExitCode = exit_code;
@@ -305,7 +305,7 @@ namespace Kernel
 
 		++this->mTeam.mProcessCount;
 
-		UserProcess& process = this->mTeam.mProcessList[pid];
+		USER_PROCESS& process = this->mTeam.mProcessList[pid];
 
 		process.Image.fCode = code;
 		process.Image.fBlob = image;
@@ -356,12 +356,12 @@ namespace Kernel
 		// React according to process kind.
 		switch (process.Kind)
 		{
-		case UserProcess::kExecutableDylibKind: {
+		case USER_PROCESS::kExecutableDylibKind: {
 			process.DylibDelegate = rtl_init_dylib(process);
 			MUST_PASS(process.DylibDelegate);
 			break;
 		}
-		case UserProcess::kExecutableKind: {
+		case USER_PROCESS::kExecutableKind: {
 			break;
 		}
 		default: {
@@ -457,7 +457,7 @@ namespace Kernel
 
 	/***********************************************************************************/
 	/// @brief Run User scheduler object.
-	/// @return UserProcess count executed within a team.
+	/// @return USER_PROCESS count executed within a team.
 	/***********************************************************************************/
 
 	SizeT UserProcessScheduler::Run() noexcept
@@ -531,13 +531,13 @@ namespace Kernel
 
 	/// @brief Gets current running process.
 	/// @return
-	Ref<UserProcess>& UserProcessScheduler::CurrentProcess()
+	Ref<USER_PROCESS>& UserProcessScheduler::CurrentProcess()
 	{
 		return mTeam.AsRef();
 	}
 
 	/// @brief Current proccess id getter.
-	/// @return UserProcess ID integer.
+	/// @return USER_PROCESS ID integer.
 	ErrorOr<PID> UserProcessHelper::TheCurrentPID()
 	{
 		if (!kScheduler.CurrentProcess())
@@ -551,7 +551,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 USER_PROCESS& process)
 	{
 		if (process.Status == ProcessStatusKind::kKilled ||
 			process.Status == ProcessStatusKind::kFinished ||