IMP: This commit contains fixes and improvements regarding the kernel, a next one will be done soon.

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

27 files changed, 133 insertions, 174 deletions

diff --git a/dev/zka/CFKit/Property.h b/dev/zka/CFKit/Property.h
index 0628e1c2..efdb9879 100644
--- a/dev/zka/CFKit/Property.h
+++ b/dev/zka/CFKit/Property.h
@@ -4,15 +4,15 @@
 
 ------------------------------------------- */
 
-#ifndef __INC_PROPS_H__
-#define __INC_PROPS_H__
+#ifndef CFKIT_PROPS_H
+#define CFKIT_PROPS_H
 
 #include <NewKit/Array.h>
 #include <NewKit/Defines.h>
 #include <NewKit/Function.h>
 #include <NewKit/String.h>
 
-#define cMaxPropLen 4096
+#define kMaxPropLen 255
 
 namespace CFKit
 {
@@ -38,7 +38,7 @@ namespace CFKit
 		StringView& GetKey();
 
 	private:
-		StringView fName{cMaxPropLen};
+		StringView fName{kMaxPropLen};
 		PropertyId fAction{No};
 	};
 
@@ -51,4 +51,4 @@ namespace Kernel
 	using namespace CFKit;
 }
 
-#endif // !__INC_PROPS_H__
+#endif // !CFKIT_PROPS_H
diff --git a/dev/zka/FSKit/IndexableProperty.h b/dev/zka/FSKit/IndexableProperty.h
index fd7082f8..fe9dea26 100644
--- a/dev/zka/FSKit/IndexableProperty.h
+++ b/dev/zka/FSKit/IndexableProperty.h
@@ -30,7 +30,7 @@ namespace Kernel
 			explicit IndexableProperty()
 				: Property()
 			{
-				Kernel::StringView strProp(cMaxPropLen);
+				Kernel::StringView strProp(kMaxPropLen);
 				strProp += "\\Properties\\Indexable";
 
 				this->GetKey() = strProp;
diff --git a/dev/zka/FSKit/NeFS.h b/dev/zka/FSKit/NeFS.h
index adcb2be3..07f667e1 100644
--- a/dev/zka/FSKit/NeFS.h
+++ b/dev/zka/FSKit/NeFS.h
@@ -134,7 +134,7 @@ struct PACKED NFS_CATALOG_STRUCT final
 	/// Catalog status flag.
 	Kernel::UInt16 Flags;
 	/// Custom catalog flags.
-	Kernel::UInt16 FileFlags;
+	Kernel::UInt16 FilkMMFlags;
 	/// Catalog kind.
 	Kernel::Int32 Kind;
 
@@ -165,7 +165,7 @@ struct PACKED NFS_FORK_STRUCT final
 
 	Kernel::Int64 ResourceId;
 	Kernel::Int32 ResourceKind;
-	Kernel::Int32 ResourceFlags;
+	Kernel::Int32 ResourckMMFlags;
 
 	Kernel::Lba	  DataOffset; // 8 Where to look for this data?
 	Kernel::SizeT DataSize;	  /// Data size according using sector count.
diff --git a/dev/zka/HALKit/AMD64/HalACPIFactoryInterface.cc b/dev/zka/HALKit/AMD64/HalACPIFactoryInterface.cc
index 2ed013ef..ccb5983f 100644
--- a/dev/zka/HALKit/AMD64/HalACPIFactoryInterface.cc
+++ b/dev/zka/HALKit/AMD64/HalACPIFactoryInterface.cc
@@ -56,7 +56,7 @@ namespace Kernel
 			UInt8  Century;
 
 			// reserved in ACPI 1.0; used since ACPI 2.0+
-			UInt16 BootArchitectureFlags;
+			UInt16 BootArchitecturkMMFlags;
 
 			UInt8  Reserved2;
 			UInt32 Flags;
diff --git a/dev/zka/HALKit/AMD64/HalCPU.cc b/dev/zka/HALKit/AMD64/HalCPUAMD64.cc
index d24bfc0a..d24bfc0a 100644
--- a/dev/zka/HALKit/AMD64/HalCPU.cc
+++ b/dev/zka/HALKit/AMD64/HalCPUAMD64.cc
diff --git a/dev/zka/HALKit/AMD64/HalMPContextSwitch.asm b/dev/zka/HALKit/AMD64/HalContextSwitchAMD64.asm
index cb054a0d..cb054a0d 100644
--- a/dev/zka/HALKit/AMD64/HalMPContextSwitch.asm
+++ b/dev/zka/HALKit/AMD64/HalContextSwitchAMD64.asm
diff --git a/dev/zka/HALKit/AMD64/HalDescriptorLoader.cc b/dev/zka/HALKit/AMD64/HalDescriptorLoader.cc
index f0eff4e1..5f7bde36 100644
--- a/dev/zka/HALKit/AMD64/HalDescriptorLoader.cc
+++ b/dev/zka/HALKit/AMD64/HalDescriptorLoader.cc
@@ -82,7 +82,7 @@ namespace Kernel::HAL
 
 	Void IDTLoader::Load(Register64& idt)
 	{
-		const auto kPITTickForScheduler = 100;
+		const Int16 kPITTickForScheduler = 100;
 
 		volatile ::Kernel::UIntPtr** ptr_ivt = (volatile ::Kernel::UIntPtr**)idt.Base;
 
diff --git a/dev/zka/HALKit/AMD64/HalKernelMain.cc b/dev/zka/HALKit/AMD64/HalKernelMain.cc
index eb195bcc..cd700eef 100644
--- a/dev/zka/HALKit/AMD64/HalKernelMain.cc
+++ b/dev/zka/HALKit/AMD64/HalKernelMain.cc
@@ -81,21 +81,28 @@ EXTERN_C void hal_init_platform(
 	Kernel::ke_stop(RUNTIME_CHECK_BOOTSTRAP);
 }
 
+EXTERN_C Kernel::Void hal_kernel_server(Kernel::Void) noexcept
+{
+	while (Yes)
+		;
+}
+
 EXTERN_C Kernel::Void hal_real_init(Kernel::Void) noexcept
 {
 	/* Initialize filesystem. */
-	Kernel::NeFileSystemMgr* mgr = Kernel::mm_new_class<Kernel::NeFileSystemMgr>();
-	Kernel::NeFileSystemMgr::Mount(mgr);
+	Kernel::NeFileSystemMgr::Mount(new Kernel::NeFileSystemMgr());
 
 	/* Initialize scheduler. */
 	Kernel::UserProcessHelper::InitializeScheduler();
 
+	const Kernel::Char kKernelServerName[255] = "KernelServer";
+
+	Kernel::rtl_create_process(&hal_kernel_server, kKernelServerName);
+
 	/* Start any cores. */
 	if (kHandoverHeader->f_HardwareTables.f_MultiProcessingEnabled)
 		Kernel::HAL::mp_get_cores(kHandoverHeader->f_HardwareTables.f_VendorPtr);
 
-	/* Load OSLdr.exe here (TODO) */
-
 	Kernel::HAL::Register64 idt_reg;
 	idt_reg.Base = (Kernel::UIntPtr)kInterruptVectorTable;
 
diff --git a/dev/zka/HALKit/AMD64/HalPagingMgr.cc b/dev/zka/HALKit/AMD64/HalPagingMgrAMD64.cc
index 1a7202d7..39f53fe4 100644
--- a/dev/zka/HALKit/AMD64/HalPagingMgr.cc
+++ b/dev/zka/HALKit/AMD64/HalPagingMgrAMD64.cc
@@ -123,24 +123,21 @@ namespace Kernel::HAL
 	/// @internal Internal function.
 	STATIC Int32 mmi_map_page_table_entry(VoidPtr virtual_address, UInt32 flags, PTE* pt_entry)
 	{
-		if (flags & ~eFlagsPresent)
-			pt_entry->Present = false;
-		else if (flags & eFlagsPresent)
-			pt_entry->Present = true;
+		pt_entry->Present = true;
 
-		if (flags & eFlagsWr)
+		if (flags & kMMFlagsWr)
 			pt_entry->Wr = true;
-		else if (flags & ~eFlagsWr)
+		else if (flags & ~kMMFlagsWr)
 			pt_entry->Wr = false;
 
-		if (flags & eFlagsNX)
+		if (flags & kMMFlagsNX)
 			pt_entry->ExecDisable = true;
-		else if (flags & ~eFlagsNX)
+		else if (flags & ~kMMFlagsNX)
 			pt_entry->ExecDisable = false;
 
-		if (flags & eFlagsUser)
+		if (flags & kMMFlagsUser)
 			pt_entry->User = true;
-		else if (flags & ~eFlagsUser)
+		else if (flags & ~kMMFlagsUser)
 			pt_entry->User = false;
 
 		hal_invl_tlb(reinterpret_cast<VoidPtr>(pt_entry));
diff --git a/dev/zka/HALKit/AMD64/HalSchedulerCore.cc b/dev/zka/HALKit/AMD64/HalSchedulerCoreAMD64.cc
index 214b889b..d4ca494c 100644
--- a/dev/zka/HALKit/AMD64/HalSchedulerCore.cc
+++ b/dev/zka/HALKit/AMD64/HalSchedulerCoreAMD64.cc
@@ -7,16 +7,6 @@
 #include <HALKit/AMD64/Processor.h>
 #include <KernelKit/UserProcessScheduler.h>
 
-using namespace Kernel;
-
-Void UserProcess::SetImageStart(VoidPtr imageStart) noexcept
-{
-	if (imageStart == nullptr)
-		this->Crash();
-
-	this->Image = imageStart;
-}
-
 namespace Kernel
 {
 	/***********************************************************************************/
diff --git a/dev/zka/HALKit/AMD64/HalTimer.cc b/dev/zka/HALKit/AMD64/HalTimerAMD64.cc
index c7f6bea3..c7f6bea3 100644
--- a/dev/zka/HALKit/AMD64/HalTimer.cc
+++ b/dev/zka/HALKit/AMD64/HalTimerAMD64.cc
diff --git a/dev/zka/HALKit/AMD64/Processor.h b/dev/zka/HALKit/AMD64/Processor.h
index 8dbac715..968cf5e9 100644
--- a/dev/zka/HALKit/AMD64/Processor.h
+++ b/dev/zka/HALKit/AMD64/Processor.h
@@ -71,11 +71,12 @@ namespace Kernel::HAL
 	/// @brief Memory Manager mapping flags.
 	enum
 	{
-		eFlagsPresent = 1 << 0,
-		eFlagsWr	  = 1 << 1,
-		eFlagsUser	  = 1 << 2,
-		eFlagsNX	  = 1 << 3,
-		eFlagsCount	  = 3,
+		kMMFlagsInvalid = 0 << 0,
+		kMMFlagsPresent = 1 << 0,
+		kMMFlagsWr		= 1 << 1,
+		kMMFlagsUser	= 1 << 2,
+		kMMFlagsNX		= 1 << 3,
+		kMMFlagsCount	= 4,
 	};
 
 	struct PACKED Register64 final
diff --git a/dev/zka/HALKit/ARM64/HalSchedulerCore.cc b/dev/zka/HALKit/ARM64/HalSchedulerCoreARM64.cc
index a384db22..49927c84 100644
--- a/dev/zka/HALKit/ARM64/HalSchedulerCore.cc
+++ b/dev/zka/HALKit/ARM64/HalSchedulerCoreARM64.cc
@@ -13,22 +13,15 @@ namespace Kernel
 		UserProcessScheduler::The().CurrentProcess().Leak().Crash();
 	}
 
-	Void UserProcess::SetImageStart(VoidPtr image_start) noexcept
-	{
-		if (image_start == 0)
-			this->Crash();
-
-		this->Image = image_start;
-	}
-
 	bool hal_check_stack(HAL::StackFramePtr stackPtr)
 	{
 		if (!stackPtr)
-			return false;
+			return No;
+
 		if (stackPtr->BP == 0 || stackPtr->SP == 0)
-			return false;
+			return No;
 
-		return true;
+		return Yes;
 	}
 
 	/// @brief Wakes up thread.
@@ -42,9 +35,6 @@ namespace Kernel
 	/// hooks and hangs thread to prevent code from executing.
 	Void mp_hang_thread(HAL::StackFrame* stack)
 	{
-		while (Yes)
-		{
-			/* Nothing to do, code is spinning */
-		}
+		ZKA_UNUSUED(stack);
 	}
 } // namespace Kernel
diff --git a/dev/zka/HALKit/ARM64/Processor.h b/dev/zka/HALKit/ARM64/Processor.h
index 5f00e345..793761e2 100644
--- a/dev/zka/HALKit/ARM64/Processor.h
+++ b/dev/zka/HALKit/ARM64/Processor.h
@@ -24,11 +24,11 @@ namespace Kernel::HAL
 	/// @brief Memory Manager mapping flags.
 	enum
 	{
-		eFlagsPresent = 1 << 0,
-		eFlagsWr	  = 1 << 1,
-		eFlagsUser	  = 1 << 2,
-		eFlagsNX	  = 1 << 3,
-		eFlagsCount	  = 3,
+		kMMFlagsPresent = 1 << 0,
+		kMMFlagsWr		= 1 << 1,
+		kMMFlagsUser	= 1 << 2,
+		kMMFlagsNX		= 1 << 3,
+		kMMFlagsCount	= 3,
 	};
 
 	/// @brief Set a PTE from pd_base.
diff --git a/dev/zka/HALKit/POWER/HalVirtualMemory.cc b/dev/zka/HALKit/POWER/HalVirtualMemory.cc
index 8d8db849..e21d7074 100644
--- a/dev/zka/HALKit/POWER/HalVirtualMemory.cc
+++ b/dev/zka/HALKit/POWER/HalVirtualMemory.cc
@@ -4,32 +4,30 @@
 
 ------------------------------------------- */
 
-#include <HALKit/POWER/ppc-cpu.h>
-#include <HALKit/POWER/ppc-mmu.h>
-
 #include <HALKit/POWER/Processor.h>
 #include <KernelKit/DebugOutput.h>
+#include <HALKit/POWER/MMU.h>
 
-/// @note refer to the SoC documentation.
+/// @note Refer to SoC documentation.
 
 using namespace Kernel;
 
-Void hal_write_tlb(UInt32 mas0, UInt32 mas1, UInt32 mas2, UInt32 mas3, UInt32 mas7)
+EXTERN_C Void hal_write_tlb(UInt32 mas0, UInt32 mas1, UInt32 mas2, UInt32 mas3, UInt32 mas7)
 {
-	mtspr(MAS0, mas0);
-	mtspr(MAS1, mas1);
-	mtspr(MAS2, mas2);
-	mtspr(MAS3, mas3);
-	mtspr(MAS7, mas7);
+	hal_mtspr(MAS0, mas0);
+	hal_mtspr(MAS1, mas1);
+	hal_mtspr(MAS2, mas2);
+	hal_mtspr(MAS3, mas3);
+	hal_mtspr(MAS7, mas7);
 
 	hal_flush_tlb();
 }
 
-Bool hal_set_tlb(UInt8 tlb, UInt32 epn, UInt64 rpn, UInt8 perms, UInt8 wimge, UInt8 ts, UInt8 esel, UInt8 tsize, UInt8 iprot)
+EXTERN_C Bool hal_set_tlb(UInt8 tlb, UInt32 epn, UInt64 rpn, UInt8 perms, UInt8 wimge, UInt8 ts, UInt8 esel, UInt8 tsize, UInt8 iprot)
 {
-	if ((mfspr(SPRN_MMUCFG) & MMUCFG_MAVN) == MMUCFG_MAVN_V1 && (tsize & 1))
+	if ((hal_mfspr(SPRN_MMUCFG) & MMUCFG_MAVN) == MMUCFG_MAVN_V1 && (tsize & 1))
 	{
-		// this mmu-version does not allow odd tsize values
+		// this MMU does not allow odd tsize values
 		return false;
 	}
 
diff --git a/dev/zka/HALKit/POWER/Hart.h b/dev/zka/HALKit/POWER/Hart.h
index eaf00493..2e40784e 100644
--- a/dev/zka/HALKit/POWER/Hart.h
+++ b/dev/zka/HALKit/POWER/Hart.h
@@ -25,7 +25,7 @@ typedef struct HAL_HARDWARE_THREAD
 {
 	Kernel::UIntPtr fStartAddress;
 	Kernel::UInt8	fPrivleged : 1;
-	Kernel::UInt32	fPageFlags;
+	Kernel::UInt32	fPagkMMFlags;
 	PPCHartType		fIdentNumber;
 } HAL_HARDWARE_THREAD;
 
diff --git a/dev/zka/HALKit/POWER/Processor.h b/dev/zka/HALKit/POWER/Processor.h
index 95c1f1c6..4df55fc4 100644
--- a/dev/zka/HALKit/POWER/Processor.h
+++ b/dev/zka/HALKit/POWER/Processor.h
@@ -29,6 +29,8 @@ namespace Kernel::HAL
 		Reg R13{0};
 		Reg R14{0};
 		Reg R15{0};
+		Reg SP{0};
+		Reg BP{0};
 	};
 
 	typedef StackFrame* StackFramePtr;
diff --git a/dev/zka/KernelKit/CodeMgr.h b/dev/zka/KernelKit/CodeMgr.h
index 41a90ec5..b8fa4c37 100644
--- a/dev/zka/KernelKit/CodeMgr.h
+++ b/dev/zka/KernelKit/CodeMgr.h
@@ -26,6 +26,6 @@ namespace Kernel
 	/// @brief Executes a new process from a function. Kernel code only.
 	/// @note This sets up a new stack, anything on the main function that calls the Kernel will not be accessible.
 	/// @param main the start of the process.
-	/// @return if the process was started or not.
-	bool sched_execute_thread(MainKind main, const Char* process_name) noexcept;
+	/// @return The team's process id.
+	SizeT rtl_create_process(MainKind main, const Char* process_name) noexcept;
 } // namespace Kernel
diff --git a/dev/zka/KernelKit/PEFCodeMgr.h b/dev/zka/KernelKit/PEFCodeMgr.h
index 73a015d3..f4e9e446 100644
--- a/dev/zka/KernelKit/PEFCodeMgr.h
+++ b/dev/zka/KernelKit/PEFCodeMgr.h
@@ -60,7 +60,7 @@ namespace Kernel
 
 	namespace Utils
 	{
-		bool execute_from_image(PEFLoader& exec, const Int32& procKind) noexcept;
+		SizeT execute_from_image(PEFLoader& exec, const Int32& procKind) noexcept;
 	} // namespace Utils
 } // namespace Kernel
 
diff --git a/dev/zka/KernelKit/UserProcessScheduler.h b/dev/zka/KernelKit/UserProcessScheduler.h
index 21e30b9b..c819b708 100644
--- a/dev/zka/KernelKit/UserProcessScheduler.h
+++ b/dev/zka/KernelKit/UserProcessScheduler.h
@@ -126,9 +126,9 @@ namespace Kernel
 	using HeapPtrKind = VoidPtr;
 
 	/// @name UserProcess
-	/// @brief User process block.
+	/// @brief User process header.
 	/// Holds information about the running process/thread.
-	struct UserProcess final
+	class UserProcess final
 	{
 	public:
 		explicit UserProcess(VoidPtr startImage = nullptr)
@@ -141,11 +141,10 @@ namespace Kernel
 		ZKA_COPY_DEFAULT(UserProcess)
 
 	public:
-		Void		  SetImageStart(VoidPtr imageStart) noexcept;
 		const UInt32& GetExitCode() noexcept;
 
 	public:
-		Char			   Name[kProcessLen] = {"ZKA Process"};
+		Char			   Name[kProcessLen] = {"Process"};
 		ProcessSubsystem   SubSystem{ProcessSubsystem::kProcessSubsystemInvalid};
 		User*			   Owner{nullptr};
 		HAL::StackFramePtr StackFrame{nullptr};
@@ -175,10 +174,11 @@ namespace Kernel
 
 		PROCESS_MEMORY_ENTRY* MemoryEntryList{nullptr};
 
-		UIntPtr MemoryPD{0UL};
+		UIntPtr VMRegister{0UL};
 
 		enum
 		{
+			kInvalidExecutableKind,
 			kExectuableKind,
 			kExectuableDLLKind,
 			kExectuableKindCount,
@@ -256,8 +256,8 @@ namespace Kernel
 
 	using UserProcessPtr = UserProcess*;
 
-	/// @brief UserProcess scheduler class.
-	/// The main class which you call to schedule processes.
+	/// @brief Process scheduler class.
+	/// The main class which you call to schedule user processes.
 	class UserProcessScheduler final : public ISchedulerObject
 	{
 		friend class UserProcessHelper;
@@ -276,7 +276,7 @@ namespace Kernel
 
 	public:
 		SizeT Add(UserProcess process);
-		Bool  Remove(ProcessID process_id);
+		const Bool  Remove(ProcessID process_id);
 
 		const Bool IsUser() override;
 		const Bool IsKernel() override;
diff --git a/dev/zka/amd64-efi.make b/dev/zka/amd64-efi.make
index e39a55ab..b877dbc7 100644
--- a/dev/zka/amd64-efi.make
+++ b/dev/zka/amd64-efi.make
@@ -58,7 +58,7 @@ newos-amd64-epm: clean
 			$(wildcard HALKit/AMD64/*.cc) $(wildcard HALKit/AMD64/*.cpp) \
 			$(wildcard HALKit/AMD64/*.s)
 	$(ASM) $(ASMFLAGS) HALKit/AMD64/HalInterruptAPI.asm
-	$(ASM) $(ASMFLAGS) HALKit/AMD64/HalMPContextSwitch.asm
+	$(ASM) $(ASMFLAGS) HALKit/AMD64/HalContextSwitchAMD64.asm
 	$(ASM) $(ASMFLAGS) HALKit/AMD64/HalBoot.asm
 	$(ASM) $(ASMFLAGS) HALKit/AMD64/HalUtils.asm
 	$(MOVEALL)
diff --git a/dev/zka/src/BitMapMgr.cc b/dev/zka/src/BitMapMgr.cc
index e97c9bfa..27158a12 100644
--- a/dev/zka/src/BitMapMgr.cc
+++ b/dev/zka/src/BitMapMgr.cc
@@ -17,9 +17,9 @@
 #include <NewKit/Defines.h>
 #include <NewKit/Stop.h>
 
-#define cBitMapMagIdx  (0)
-#define cBitMapSizeIdx (1)
-#define cBitMapUsedIdx (2)
+#define kBitMapMagIdx  (0)
+#define kBitMapSizeIdx (1)
+#define kBitMapUsedIdx (2)
 
 namespace Kernel
 {
@@ -43,8 +43,8 @@ namespace Kernel
 
 					UIntPtr* ptr_bit_set = reinterpret_cast<UIntPtr*>(page_ptr);
 
-					if (!ptr_bit_set[cBitMapMagIdx] ||
-						ptr_bit_set[cBitMapMagIdx] != kBitMapMagic)
+					if (!ptr_bit_set[kBitMapMagIdx] ||
+						ptr_bit_set[kBitMapMagIdx] != kBitMapMagic)
 						return No;
 
 					return Yes;
@@ -57,28 +57,24 @@ namespace Kernel
 
 					UIntPtr* ptr_bit_set = reinterpret_cast<UIntPtr*>(page_ptr);
 
-					ptr_bit_set[cBitMapMagIdx]	= kBitMapMagic;
-					ptr_bit_set[cBitMapUsedIdx] = No;
+					ptr_bit_set[kBitMapMagIdx]	= kBitMapMagic;
+					ptr_bit_set[kBitMapUsedIdx] = No;
 
 					this->GetBitMapStatus(ptr_bit_set);
 
-					mm_map_page(ptr_bit_set, ~eFlagsPresent);
-					mm_map_page(ptr_bit_set, ~eFlagsWr);
-					mm_map_page(ptr_bit_set, ~eFlagsUser);
-
 					return Yes;
 				}
 
-				UInt32 MakeFlags(Bool wr, Bool user)
+				UInt32 MakeMMFlags(Bool wr, Bool user)
 				{
 
-					UInt32 flags = eFlagsPresent;
+					UInt32 flags = kMMFlagsPresent;
 
 					if (wr)
-						flags |= eFlagsWr;
+						flags |= kMMFlagsWr;
 
 					if (user)
-						flags |= eFlagsUser;
+						flags |= kMMFlagsUser;
 
 					return flags;
 				}
@@ -93,33 +89,33 @@ namespace Kernel
 					{
 						UIntPtr* ptr_bit_set = reinterpret_cast<UIntPtr*>(base);
 
-						if (ptr_bit_set[cBitMapMagIdx] == kBitMapMagic &&
-							ptr_bit_set[cBitMapSizeIdx] <= size)
+						if (ptr_bit_set[kBitMapMagIdx] == kBitMapMagic &&
+							ptr_bit_set[kBitMapSizeIdx] <= size)
 						{
-							if (ptr_bit_set[cBitMapUsedIdx] == No)
+							if (ptr_bit_set[kBitMapUsedIdx] == No)
 							{
-								ptr_bit_set[cBitMapSizeIdx] = size;
-								ptr_bit_set[cBitMapUsedIdx] = Yes;
+								ptr_bit_set[kBitMapSizeIdx] = size;
+								ptr_bit_set[kBitMapUsedIdx] = Yes;
 
 								this->GetBitMapStatus(ptr_bit_set);
 
-								UInt32 flags = this->MakeFlags(wr, user);
+								UInt32 flags = this->MakeMMFlags(wr, user);
 								mm_map_page(ptr_bit_set, flags);
 
 								return (VoidPtr)ptr_bit_set;
 							}
 						}
-						else if (ptr_bit_set[cBitMapMagIdx] != kBitMapMagic)
+						else if (ptr_bit_set[kBitMapMagIdx] != kBitMapMagic)
 						{
 							UIntPtr* ptr_bit_set = reinterpret_cast<UIntPtr*>(base_ptr);
 
-							ptr_bit_set[cBitMapMagIdx]	= kBitMapMagic;
-							ptr_bit_set[cBitMapSizeIdx] = size;
-							ptr_bit_set[cBitMapUsedIdx] = Yes;
+							ptr_bit_set[kBitMapMagIdx]	= kBitMapMagic;
+							ptr_bit_set[kBitMapSizeIdx] = size;
+							ptr_bit_set[kBitMapUsedIdx] = Yes;
 
 							this->GetBitMapStatus(ptr_bit_set);
 
-							UInt32 flags = this->MakeFlags(wr, user);
+							UInt32 flags = this->MakeMMFlags(wr, user);
 							mm_map_page(ptr_bit_set, flags);
 
 							return (VoidPtr)ptr_bit_set;
@@ -143,13 +139,13 @@ namespace Kernel
 						return;
 					}
 
-					kcout << "Magic Number: " << hex_number(ptr_bit_set[cBitMapMagIdx]) << endl;
-					kcout << "Is Allocated: " << (ptr_bit_set[cBitMapUsedIdx] ? "Yes" : "No") << endl;
-					kcout << "Size of BitMap (B): " << number(ptr_bit_set[cBitMapSizeIdx]) << endl;
-					kcout << "Size of BitMap (KIB): " << number(KIB(ptr_bit_set[cBitMapSizeIdx])) << endl;
-					kcout << "Size of BitMap (MIB): " << number(MIB(ptr_bit_set[cBitMapSizeIdx])) << endl;
-					kcout << "Size of BitMap (GIB): " << number(GIB(ptr_bit_set[cBitMapSizeIdx])) << endl;
-					kcout << "Size of BitMap (TIB): " << number(TIB(ptr_bit_set[cBitMapSizeIdx])) << endl;
+					kcout << "Magic Number: " << hex_number(ptr_bit_set[kBitMapMagIdx]) << endl;
+					kcout << "Is Allocated: " << (ptr_bit_set[kBitMapUsedIdx] ? "Yes" : "No") << endl;
+					kcout << "Size of BitMap (B): " << number(ptr_bit_set[kBitMapSizeIdx]) << endl;
+					kcout << "Size of BitMap (KIB): " << number(KIB(ptr_bit_set[kBitMapSizeIdx])) << endl;
+					kcout << "Size of BitMap (MIB): " << number(MIB(ptr_bit_set[kBitMapSizeIdx])) << endl;
+					kcout << "Size of BitMap (GIB): " << number(GIB(ptr_bit_set[kBitMapSizeIdx])) << endl;
+					kcout << "Size of BitMap (TIB): " << number(TIB(ptr_bit_set[kBitMapSizeIdx])) << endl;
 					kcout << "Address Of BitMap: " << hex_number((UIntPtr)ptr_bit_set) << endl;
 				}
 			};
@@ -171,15 +167,6 @@ namespace Kernel
 				return nullptr;
 			}
 
-			if (wr)
-				mm_map_page(ptr_new, eFlagsWr | eFlagsPresent);
-			else if (user && wr)
-				mm_map_page(ptr_new, eFlagsUser | eFlagsWr | eFlagsPresent);
-			else if (user)
-				mm_map_page(ptr_new, eFlagsUser | eFlagsPresent);
-			else
-				mm_map_page(ptr_new, eFlagsPresent);
-
 			return (UIntPtr*)ptr_new;
 		}
 
@@ -192,11 +179,6 @@ namespace Kernel
 			Detail::IBitMapAllocator traits;
 			Bool					 ret = traits.FreeBitMap(page_ptr);
 
-			if (ret)
-			{
-				mm_map_page(page_ptr, ~eFlagsPresent);
-			}
-
 			return ret;
 		}
 	} // namespace HAL
diff --git a/dev/zka/src/CodeMgr.cc b/dev/zka/src/CodeMgr.cc
index 130f8cfe..c855347b 100644
--- a/dev/zka/src/CodeMgr.cc
+++ b/dev/zka/src/CodeMgr.cc
@@ -4,8 +4,8 @@
 
 ------------------------------------------- */
 
-#include <NewKit/Utils.h>
 #include <KernelKit/CodeMgr.h>
+#include <NewKit/Utils.h>
 #include <KernelKit/UserProcessScheduler.h>
 
 namespace Kernel
@@ -14,20 +14,20 @@ namespace Kernel
 	/// @note This sets up a new stack, anything on the main function that calls the Kernel will not be accessible.
 	/// @param main the start of the process.
 	/// @return if the process was started or not.
-	Bool sched_execute_thread(MainKind main, const Char* process_name) noexcept
+	SizeT rtl_create_process(MainKind main, const Char* process_name) noexcept
 	{
 		if (!main)
 			return No;
 
 		UserProcess proc;
-		proc.SetImageStart(reinterpret_cast<VoidPtr>(main));
 
+		proc.Image	   = reinterpret_cast<VoidPtr>(main);
 		proc.Kind	   = UserProcess::kExectuableKind;
 		proc.StackSize = kib_cast(32);
 
 		rt_set_memory(proc.Name, 0, kProcessLen);
 		rt_copy_memory((VoidPtr)process_name, proc.Name, rt_string_len(process_name));
 
-		return UserProcessScheduler::The().Add(proc) > 0;
+		return UserProcessScheduler::The().Add(proc);
 	}
 } // namespace Kernel
diff --git a/dev/zka/src/GUIDWizard.cc b/dev/zka/src/GUIDWizard.cc
index d72c77eb..cb4fc50b 100644
--- a/dev/zka/src/GUIDWizard.cc
+++ b/dev/zka/src/GUIDWizard.cc
@@ -26,9 +26,9 @@ namespace CFKit::XRN::Version1
 
 		Ref<GUIDSequence*> seq_ref{seq};
 
-		seq_ref.Leak()->fMs1	   = uuidSeq[0];
-		seq_ref.Leak()->fMs2	   = uuidSeq[1];
-		seq_ref.Leak()->fMs3	   = uuidSeq[2];
+		seq_ref.Leak()->fMs1	= uuidSeq[0];
+		seq_ref.Leak()->fMs2	= uuidSeq[1];
+		seq_ref.Leak()->fMs3	= uuidSeq[2];
 		seq_ref.Leak()->fMs4[0] = uuidSeq[3];
 		seq_ref.Leak()->fMs4[1] = uuidSeq[4];
 		seq_ref.Leak()->fMs4[2] = uuidSeq[5];
diff --git a/dev/zka/src/PEFCodeMgr.cc b/dev/zka/src/PEFCodeMgr.cc
index 593910be..44c14b42 100644
--- a/dev/zka/src/PEFCodeMgr.cc
+++ b/dev/zka/src/PEFCodeMgr.cc
@@ -201,16 +201,16 @@ namespace Kernel
 
 	namespace Utils
 	{
-		Bool execute_from_image(PEFLoader& exec, const Int32& procKind) noexcept
+		SizeT execute_from_image(PEFLoader& exec, const Int32& procKind) noexcept
 		{
 			auto errOrStart = exec.FindStart();
 
 			if (errOrStart.Error() != kErrorSuccess)
-				return false;
+				return No;
 
 			UserProcess proc;
 
-			proc.SetImageStart(errOrStart.Leak().Leak());
+			proc.Image		 = errOrStart.Leak().Leak();
 			proc.Kind		 = procKind;
 			proc.StackSize	 = *(UIntPtr*)exec.FindSymbol(cPefStackSizeSymbol, kPefData);
 			proc.MemoryLimit = *(UIntPtr*)exec.FindSymbol(cPefHeapSizeSymbol, kPefData);
@@ -218,18 +218,15 @@ namespace Kernel
 			rt_set_memory(proc.Name, 0, kProcessLen);
 
 			if (exec.FindSymbol(cPefNameSymbol, kPefData))
-				rt_copy_memory((VoidPtr)exec.FindSymbol(cPefNameSymbol, kPefData), proc.Name, rt_string_len((Char*)exec.FindSymbol(cPefNameSymbol, kPefData)));
-			else
-				rt_copy_memory((VoidPtr) "UNNAMED PROCESS.", proc.Name, rt_string_len("UNNAMED PROCESS."));
+				rt_copy_memory(exec.FindSymbol(cPefNameSymbol, kPefData), proc.Name, rt_string_len((Char*)exec.FindSymbol(cPefNameSymbol, kPefData)));
 
 			if (!proc.StackSize)
 			{
 				const auto cDefaultStackSizeMib = 8;
-
 				proc.StackSize = mib_cast(cDefaultStackSizeMib);
 			}
 
-			return UserProcessScheduler::The().Add(proc) > 0;
+			return UserProcessScheduler::The().Add(proc);
 		}
 	} // namespace Utils
 
diff --git a/dev/zka/src/UserProcessScheduler.cc b/dev/zka/src/UserProcessScheduler.cc
index 05c2b35e..844afa5d 100644
--- a/dev/zka/src/UserProcessScheduler.cc
+++ b/dev/zka/src/UserProcessScheduler.cc
@@ -113,7 +113,7 @@ namespace Kernel
 	{
 #ifdef __ZKA_AMD64__
 		auto pd = hal_read_cr3();
-		hal_write_cr3(reinterpret_cast<VoidPtr>(this->MemoryPD));
+		hal_write_cr3(reinterpret_cast<VoidPtr>(this->VMRegister));
 
 		auto ptr = mm_new_heap(sz, Yes, Yes);
 
@@ -174,7 +174,7 @@ namespace Kernel
 			{
 #ifdef __ZKA_AMD64__
 				auto pd = hal_read_cr3();
-				hal_write_cr3(reinterpret_cast<VoidPtr>(this->MemoryPD));
+				hal_write_cr3(reinterpret_cast<VoidPtr>(this->VMRegister));
 
 				auto ret = mm_delete_heap(entry->MemoryEntry);
 
@@ -250,7 +250,7 @@ namespace Kernel
 			{
 #ifdef __ZKA_AMD64__
 				auto pd = hal_read_cr3();
-				hal_write_cr3(reinterpret_cast<VoidPtr>(this->MemoryPD));
+				hal_write_cr3(reinterpret_cast<VoidPtr>(this->VMRegister));
 #endif
 
 				MUST_PASS(mm_delete_heap(memory_list->MemoryEntry));
@@ -269,7 +269,7 @@ namespace Kernel
 		}
 
 		//! Free the memory's page directory.
-		HAL::mm_free_bitmap(reinterpret_cast<VoidPtr>(this->MemoryPD));
+		HAL::mm_free_bitmap(reinterpret_cast<VoidPtr>(this->VMRegister));
 
 		//! Delete image if not done already.
 		if (this->Image && mm_is_valid_heap(this->Image))
@@ -310,14 +310,12 @@ namespace Kernel
 	SizeT UserProcessScheduler::Add(UserProcess process)
 	{
 		if (mTeam.mProcessAmount > kSchedProcessLimitPerTeam)
-			return 0;
+			return -kErrorInvalidData;
 
 #ifdef __ZKA_AMD64__
-		process.MemoryPD = reinterpret_cast<UIntPtr>(HAL::mm_alloc_bitmap(Yes, Yes, sizeof(PDE), Yes));
+		process.VMRegister = reinterpret_cast<UIntPtr>(HAL::mm_alloc_bitmap(Yes, Yes, sizeof(PDE), Yes));
 #endif // __ZKA_AMD64__
 
-		process.Status = ProcessStatusKind::kStarting;
-
 		process.StackFrame = (HAL::StackFramePtr)mm_new_heap(sizeof(HAL::StackFrame), Yes, Yes);
 
 		if (!process.StackFrame)
@@ -347,22 +345,18 @@ namespace Kernel
 
 		if (!process.StackReserve)
 		{
-			mm_delete_heap(process.StackFrame);
-			process.StackFrame = nullptr;
+			process.Crash();
 			return -kErrorProcessFault;
 		}
 
 		++mTeam.mProcessAmount;
 
 		process.ProcessId = mTeam.mProcessAmount;
-		process.Status	  = ProcessStatusKind::kRunning;
-
-		// avoid the pitfalls of moving process.
-		auto ret_pid = process.ProcessId;
+		process.Status	  = ProcessStatusKind::kStarting;
 
-		mTeam.AsArray()[process.ProcessId] = move(process);
+		mTeam.AsArray()[process.ProcessId] = process;
 
-		return ret_pid;
+		return process.ProcessId;
 	}
 
 	/***********************************************************************************/
@@ -384,7 +378,7 @@ namespace Kernel
 
 	/***********************************************************************************/
 
-	Bool UserProcessScheduler::Remove(ProcessID process_id)
+	const Bool UserProcessScheduler::Remove(ProcessID process_id)
 	{
 		// check if process is within range.
 		if (process_id > mTeam.AsArray().Count())
@@ -408,6 +402,7 @@ namespace Kernel
 
 	const Bool UserProcessScheduler::HasMP()
 	{
+		MUST_PASS(kHandoverHeader);
 		return kHandoverHeader->f_HardwareTables.f_MultiProcessingEnabled;
 	}
 
@@ -447,7 +442,7 @@ namespace Kernel
 				this->CurrentProcess() = process;
 
 				// tell helper to find a core to schedule on.
-				if (!UserProcessHelper::Switch(process.Image, &process.StackReserve[process.StackSize - 1], process.StackFrame,
+				if (!UserProcessHelper::Switch(process.Image, &process.StackReserve[process.StackSize], process.StackFrame,
 											   process.ProcessId))
 				{
 					process.Crash();
diff --git a/dev/zka/src/Utils.cc b/dev/zka/src/Utils.cc
index 7427fe34..53f98391 100644
--- a/dev/zka/src/Utils.cc
+++ b/dev/zka/src/Utils.cc
@@ -34,14 +34,15 @@ namespace Kernel
 	Size rt_string_len(const Char* str, SizeT _len)
 	{
 		Size len{0};
+
 		while (str[len] != '\0')
 		{
 			if (len > _len)
 			{
-				return 0;
+				return _len;
 			}
 
-			len++;
+			++len;
 		}
 
 		return len;
@@ -49,14 +50,11 @@ namespace Kernel
 
 	Size rt_string_len(const Char* ptr)
 	{
-		if (*ptr == 0)
-			return 0;
+		SizeT cnt{0};
 
-		SizeT cnt = 0;
-
-		while (ptr[cnt] != (Char)0)
+		while (ptr[cnt] != 0)
 		{
-			cnt++;
+			++cnt;
 		}
 
 		return cnt;
@@ -104,7 +102,7 @@ namespace Kernel
 	Int rt_copy_memory(const voidPtr src, voidPtr dst, Size len)
 	{
 		if (len < 1)
-			return -2;
+			return 0;
 
 		char* srcChr  = reinterpret_cast<char*>(src);
 		char* dstChar = reinterpret_cast<char*>(dst);
@@ -125,11 +123,13 @@ namespace Kernel
 			return nullptr;
 
 		const Char* string = new Char[rt_string_len(text)];
+
 		if (!string)
 			return nullptr;
 
 		voidPtr vText = reinterpret_cast<voidPtr>(const_cast<char*>(text));
 		voidPtr vStr  = reinterpret_cast<voidPtr>(const_cast<char*>(string));
+
 		rt_copy_memory(vText, vStr, rt_string_len(text));
 
 		return string;