Fixed many issues with the kernel, and refactored it.

Signed-off-by: Amlal EL Mahrouss <amlalelmahrouss@icloud.com>

19 files changed, 109 insertions, 421 deletions

diff --git a/dev/ZKA/ArchKit/ArchKit.hxx b/dev/ZKA/ArchKit/ArchKit.hxx
index f0f3a2ae..9659182c 100644
--- a/dev/ZKA/ArchKit/ArchKit.hxx
+++ b/dev/ZKA/ArchKit/ArchKit.hxx
@@ -91,6 +91,11 @@ struct HAL_SYSCALL_RECORD final
 	Kernel::Int64	fHash;
 	Kernel::Bool	fHooked;
 	rt_syscall_proc fProc;
+
+	operator bool()
+	{
+		return fHooked;
+	}
 };
 
 inline Kernel::Array<HAL_SYSCALL_RECORD,
diff --git a/dev/ZKA/HALKit/AMD64/HalCoreMultiProcessingAMD64.cxx b/dev/ZKA/HALKit/AMD64/HalCoreMultiProcessingAMD64.cxx
index ca38229d..4566a710 100644
--- a/dev/ZKA/HALKit/AMD64/HalCoreMultiProcessingAMD64.cxx
+++ b/dev/ZKA/HALKit/AMD64/HalCoreMultiProcessingAMD64.cxx
@@ -153,7 +153,7 @@ namespace Kernel::HAL
 
 	EXTERN_C HAL::StackFramePtr _hal_leak_current_context(Void)
 	{
-		return fBlocks[ProcessScheduler::The().Leak().TheCurrent().Leak().ProcessId % cMaxPCBBlocks].f_Frame;
+		return fBlocks[ProcessScheduler::The().CurrentProcess().Leak().ProcessId % cMaxPCBBlocks].f_Frame;
 	}
 
 	EXTERN_C Void hal_switch_context(HAL::StackFramePtr stack_frame)
@@ -163,10 +163,10 @@ namespace Kernel::HAL
 		const auto cDurationSeconds = Seconds(5);
 
 		HardwareTimer timer(cDurationSeconds);
-		semaphore_process.LockOrWait(&ProcessScheduler::The().Leak().TheCurrent().Leak(), &timer);
+		semaphore_process.LockOrWait(&ProcessScheduler::The().CurrentProcess().Leak(), &timer);
 
-		fBlocks[ProcessScheduler::The().Leak().TheCurrent().Leak().ProcessId % cMaxPCBBlocks].f_PHB	  = &ProcessScheduler::The().Leak().TheCurrent().Leak();
-		fBlocks[ProcessScheduler::The().Leak().TheCurrent().Leak().ProcessId % cMaxPCBBlocks].f_Frame = stack_frame;
+		fBlocks[ProcessScheduler::The().CurrentProcess().Leak().ProcessId % cMaxPCBBlocks].f_PHB	  = &ProcessScheduler::The().CurrentProcess().Leak();
+		fBlocks[ProcessScheduler::The().CurrentProcess().Leak().ProcessId % cMaxPCBBlocks].f_Frame = stack_frame;
 
 		mp_do_context_switch(stack_frame);
 
diff --git a/dev/ZKA/HALKit/AMD64/HalKernelMain.cxx b/dev/ZKA/HALKit/AMD64/HalKernelMain.cxx
index adfd6894..4d0cfdb6 100644
--- a/dev/ZKA/HALKit/AMD64/HalKernelMain.cxx
+++ b/dev/ZKA/HALKit/AMD64/HalKernelMain.cxx
@@ -12,7 +12,6 @@
 #include <KernelKit/Heap.hxx>
 #include <KernelKit/PEFCodeManager.hxx>
 #include <KernelKit/ProcessScheduler.hxx>
-#include <KernelKit/ProcessHeap.hxx>
 #include <NewKit/Json.hxx>
 #include <Modules/CoreCG/Accessibility.hxx>
 #include <KernelKit/CodeManager.hxx>
@@ -144,7 +143,7 @@ Kernel::Void hal_real_init(Kernel::Void) noexcept
 	kSyscalls[cTlsInterrupt].fProc = [](Kernel::VoidPtr rdx) -> void {
 		if (tls_check_syscall_impl(rdx) == false)
 		{
-			Kernel::ProcessScheduler::The().Leak().TheCurrent().Leak().Crash();
+			Kernel::ProcessScheduler::The().CurrentProcess().Leak().Crash();
 		}
 	};
 
@@ -156,7 +155,7 @@ Kernel::Void hal_real_init(Kernel::Void) noexcept
 			return;
 
 		// assign the fThe field with the pointer.
-		rdxInf->fThe = Kernel::ProcessScheduler::The().Leak().TheCurrent().Leak().New(rdxInf->fTheSz);
+		rdxInf->fThe = Kernel::ProcessScheduler::The().CurrentProcess().Leak().New(rdxInf->fTheSz);
 	};
 
 	kSyscalls[cDeleteInterrupt].fProc = [](Kernel::VoidPtr rdx) -> void {
@@ -167,7 +166,7 @@ Kernel::Void hal_real_init(Kernel::Void) noexcept
 			return;
 
 		// delete ptr with sz in mind.
-		Kernel::ProcessScheduler::The().Leak().TheCurrent().Leak().Delete(rdxInf->fThe, rdxInf->fTheSz);
+		Kernel::ProcessScheduler::The().CurrentProcess().Leak().Delete(rdxInf->fThe, rdxInf->fTheSz);
 	};
 
 	kSyscalls[cTlsInstallInterrupt].fProc = [](Kernel::VoidPtr rdx) -> void {
@@ -187,7 +186,7 @@ Kernel::Void hal_real_init(Kernel::Void) noexcept
 			return;
 
 		Kernel::kcout << "newoskrnl: " << rdxEi->fReason << "\r";
-		Kernel::ProcessScheduler::The().Leak().TheCurrent().Leak().Exit(rdxEi->fCode);
+		Kernel::ProcessScheduler::The().CurrentProcess().Leak().Exit(rdxEi->fCode);
 	};
 
 	kSyscalls[cLastExitInterrupt].fProc = [](Kernel::VoidPtr rdx) -> void {
diff --git a/dev/ZKA/HALKit/ARM64/HalKernelMain.cxx b/dev/ZKA/HALKit/ARM64/HalKernelMain.cxx
index c2886b31..31468fa2 100644
--- a/dev/ZKA/HALKit/ARM64/HalKernelMain.cxx
+++ b/dev/ZKA/HALKit/ARM64/HalKernelMain.cxx
@@ -113,7 +113,7 @@ Kernel::Void hal_real_init(Kernel::Void) noexcept
 	kSyscalls[cTlsInterrupt].Leak().Leak()->fProc = [](Kernel::VoidPtr rdx) -> void {
 		if (tls_check_syscall_impl(rdx) == false)
 		{
-			Kernel::ProcessScheduler::The().Leak().TheCurrent().Leak().Crash();
+			Kernel::ProcessScheduler::The().Leak().CurrentProcess().Leak().Crash();
 		}
 	};
 
@@ -125,7 +125,7 @@ Kernel::Void hal_real_init(Kernel::Void) noexcept
 			return;
 
 		// assign the fThe field with the pointer.
-		rdxInf->fThe = Kernel::ProcessScheduler::The().Leak().TheCurrent().Leak().New(rdxInf->fTheSz);
+		rdxInf->fThe = Kernel::ProcessScheduler::The().Leak().CurrentProcess().Leak().New(rdxInf->fTheSz);
 	};
 
 	kSyscalls[cDeleteInterrupt].Leak().Leak()->fProc = [](Kernel::VoidPtr rdx) -> void {
@@ -136,7 +136,7 @@ Kernel::Void hal_real_init(Kernel::Void) noexcept
 			return;
 
 		// delete ptr with sz in mind.
-		Kernel::ProcessScheduler::The().Leak().TheCurrent().Leak().Delete(rdxInf->fThe, rdxInf->fTheSz);
+		Kernel::ProcessScheduler::The().Leak().CurrentProcess().Leak().Delete(rdxInf->fThe, rdxInf->fTheSz);
 	};
 
 	kSyscalls[cTlsInstallInterrupt].Leak().Leak()->fProc = [](Kernel::VoidPtr rdx) -> void {
@@ -156,7 +156,7 @@ Kernel::Void hal_real_init(Kernel::Void) noexcept
 			return;
 
 		Kernel::kcout << "newoskrnl: " << rdxEi->fReason << "\r";
-		Kernel::ProcessScheduler::The().Leak().TheCurrent().Leak().Exit(rdxEi->fCode);
+		Kernel::ProcessScheduler::The().Leak().CurrentProcess().Leak().Exit(rdxEi->fCode);
 	};
 
 	kSyscalls[cLastExitInterrupt].Leak().Leak()->fProc = [](Kernel::VoidPtr rdx) -> void {
diff --git a/dev/ZKA/KernelKit/LPC.hxx b/dev/ZKA/KernelKit/LPC.hxx
index 6553f45c..152e7295 100644
--- a/dev/ZKA/KernelKit/LPC.hxx
+++ b/dev/ZKA/KernelKit/LPC.hxx
@@ -11,9 +11,9 @@
 /// @file LPC.hxx
 /// @brief Local Process Codes.
 
-#define ErrLocalIsOk()	 (Kernel::ProcessScheduler::The().Leak().TheCurrent().Leak().GetLocalCode() == Kernel::kErrorSuccess)
-#define ErrLocalFailed() (Kernel::ProcessScheduler::The().Leak().TheCurrent().Leak().GetLocalCode() != Kernel::kErrorSuccess)
-#define ErrLocal()		 Kernel::ProcessScheduler::The().Leak().TheCurrent().Leak().GetLocalCode()
+#define ErrLocalIsOk()	 (Kernel::ProcessScheduler::The().CurrentProcess().Leak().GetLocalCode() == Kernel::kErrorSuccess)
+#define ErrLocalFailed() (Kernel::ProcessScheduler::The().CurrentProcess().Leak().GetLocalCode() != Kernel::kErrorSuccess)
+#define ErrLocal()		 Kernel::ProcessScheduler::The().CurrentProcess().Leak().GetLocalCode()
 
 namespace Kernel
 {
diff --git a/dev/ZKA/KernelKit/ProcessHeap.hxx b/dev/ZKA/KernelKit/ProcessHeap.hxx
deleted file mode 100644
index 820daa76..00000000
--- a/dev/ZKA/KernelKit/ProcessHeap.hxx
+++ /dev/null
@@ -1,44 +0,0 @@
-/* -------------------------------------------
-
-	Copyright ZKA Technologies.
-
-------------------------------------------- */
-
-#pragma once
-
-#include <NewKit/Array.hxx>
-#include <NewKit/ArrayList.hxx>
-#include <NewKit/ErrorOr.hxx>
-#include <NewKit/PageManager.hxx>
-#include <NewKit/Ref.hxx>
-#include <NewKit/Pmm.hxx>
-
-/// @version 5/11/23
-/// @file ProcessHeap.hxx
-/// @brief Process heap allocator.
-
-#define kProcessHeapMag   (0xFAF0FEF0)
-
-namespace Kernel
-{
-	typedef enum
-	{
-		/// @brief Shared heap.
-		kProcessHeapShared = 0x4,
-		/// @brief User and private heap.
-		kProcessHeapUser = 0x6,
-		/// @brief Read and Write heap.
-		kProcessHeapRw = 0x8,
-	} UserHeapFlags;
-
-	/// @brief Allocate a process heap, no zero out is done here.
-	/// @param flags the heap's flags.
-	/// @param initial_len_in_gib the initial heap's length in GB.
-	/// @return The process's heap.
-	VoidPtr sched_new_heap(Int32 flags, SizeT initial_len_in_gib);
-
-	/// @brief Frees the process heap.
-	/// @param pointer The process heap pointer.
-	/// @return status code of the freeing.
-	Int32 sched_free_heap(voidPtr pointer);
-} // namespace Kernel
diff --git a/dev/ZKA/KernelKit/ProcessScheduler.hxx b/dev/ZKA/KernelKit/ProcessScheduler.hxx
index b0756522..5534c591 100644
--- a/dev/ZKA/KernelKit/ProcessScheduler.hxx
+++ b/dev/ZKA/KernelKit/ProcessScheduler.hxx
@@ -10,7 +10,6 @@
 #include <ArchKit/ArchKit.hxx>
 #include <KernelKit/LockDelegate.hxx>
 #include <KernelKit/User.hxx>
-#include <KernelKit/ProcessHeap.hxx>
 #include <NewKit/MutableArray.hxx>
 
 #define kSchedMinMicroTime (AffinityKind::kStandard)
@@ -40,7 +39,6 @@ namespace Kernel
 	//! @brief Process name length.
 	inline constexpr SizeT kProcessLen = 256U;
 
-
 	//! @brief Process status enum.
 	enum class ProcessStatus : Int32
 	{
@@ -58,7 +56,7 @@ namespace Kernel
 		kInvalid	  = 300,
 		kVeryHigh	  = 250,
 		kHigh		  = 200,
-		kStandard = 150,
+		kStandard	  = 150,
 		kLowUsage	  = 100,
 		kVeryLowUsage = 50,
 	};
@@ -126,7 +124,7 @@ namespace Kernel
 
 	/// @name PROCESS_HEADER_BLOCK
 	/// @brief Process Header Block (PHB).
-	   /// Holds information about the running process/thread.
+	/// Holds information about the running process/thread.
 	struct PROCESS_HEADER_BLOCK final
 	{
 	public:
@@ -140,13 +138,13 @@ namespace Kernel
 		ZKA_COPY_DEFAULT(PROCESS_HEADER_BLOCK)
 
 	public:
-		void		 SetEntrypoint(UIntPtr& imageStart) noexcept;
+		void		  SetEntrypoint(UIntPtr& imageStart) noexcept;
 		const UInt32& GetExitCode() noexcept;
 
 	public:
 		Char			   Name[kProcessLen] = {"PROCESS #0 (TEAM 0)"};
 		ProcessSubsystem   SubSystem{ProcessSubsystem::eProcessSubsystemInvalid};
-		User*              AssignedOwner{nullptr};
+		User*			   AssignedOwner{nullptr};
 		HAL::StackFramePtr StackFrame{nullptr};
 		AffinityKind	   Affinity{AffinityKind::kStandard};
 		ProcessStatus	   Status{ProcessStatus::kDead};
@@ -157,7 +155,7 @@ namespace Kernel
 		HeapPtrKind HeapPtr{nullptr};
 
 		// shared library handle, reserved for kSharedObjectKind types of executables only.
-		PEFDLLInterface* DLLPtr{nullptr};
+		PEFDLLInterface*	  DLLPtr{nullptr};
 		PROCESS_HEADER_BLOCK* Parent{nullptr};
 
 		// Memory usage.
@@ -167,7 +165,7 @@ namespace Kernel
 
 		enum
 		{
-			kExeKind   = 1,
+			kExeKind		  = 1,
 			kSharedObjectKind = 2,
 			kKindCount,
 		};
@@ -211,13 +209,13 @@ namespace Kernel
 		//! @return Int32 local error code.
 		Int32& GetLocalCode() noexcept;
 
-		const User* GetOwner() noexcept;
-		const ProcessStatus&   GetStatus() noexcept;
-		const AffinityKind&	   GetAffinity() noexcept;
+		const User*			 GetOwner() noexcept;
+		const ProcessStatus& GetStatus() noexcept;
+		const AffinityKind&	 GetAffinity() noexcept;
 
 	private:
 		UInt32 fLastExitCode{0};
-		Int32 fLocalCode{0};
+		Int32  fLocalCode{0};
 
 		friend ProcessScheduler;
 		friend ProcessHelper;
@@ -234,23 +232,24 @@ namespace Kernel
 		ZKA_COPY_DEFAULT(ProcessTeam);
 
 		Array<PROCESS_HEADER_BLOCK, kSchedProcessLimitPerTeam>& AsArray();
-		Ref<PROCESS_HEADER_BLOCK>&				  AsRef();
-		UInt64&							  Id() noexcept;
+		Ref<PROCESS_HEADER_BLOCK>&								AsRef();
+		ProcessID&													Id() noexcept;
 
 	public:
 		Array<PROCESS_HEADER_BLOCK, kSchedProcessLimitPerTeam> mProcessList;
-		Ref<PROCESS_HEADER_BLOCK>				 mCurrentProcess;
-		UInt64							 mTeamId{0};
+		Ref<PROCESS_HEADER_BLOCK>							   mCurrentProcess;
+		SizeT												   mProcessAmount{0};
+		ProcessID											   mTeamId{0};
 	};
 
-	using ProcessHeaderRef = PROCESS_HEADER_BLOCK*;
+	using PROCESS_HEADER_BLOCK_PTR = PROCESS_HEADER_BLOCK*;
 
 	/// @brief PROCESS_HEADER_BLOCK manager class.
 	/// The main class which you call to schedule an app.
 	class ProcessScheduler final
 	{
 	public:
-	explicit ProcessScheduler() = default;
+		explicit ProcessScheduler() = default;
 
 		~ProcessScheduler() = default;
 
@@ -263,15 +262,15 @@ namespace Kernel
 		ProcessTeam& CurrentTeam();
 
 	public:
-		SizeT Add(Ref<PROCESS_HEADER_BLOCK> processRef);
-		Bool  Remove(SizeT processSlot);
+		SizeT Add(PROCESS_HEADER_BLOCK& processRef);
+		Bool  Remove(ProcessID processSlot);
 
 	public:
-		Ref<PROCESS_HEADER_BLOCK>& TheCurrent();
-		SizeT				Run() noexcept;
+		Ref<PROCESS_HEADER_BLOCK>& CurrentProcess();
+		SizeT					   Run() noexcept;
 
 	public:
-		STATIC Ref<ProcessScheduler> The();
+		STATIC ProcessScheduler& The();
 
 	private:
 		ProcessTeam mTeam;
diff --git a/dev/ZKA/KernelKit/Semaphore.hxx b/dev/ZKA/KernelKit/Semaphore.hxx
index 7f6b2001..685b00a3 100644
--- a/dev/ZKA/KernelKit/Semaphore.hxx
+++ b/dev/ZKA/KernelKit/Semaphore.hxx
@@ -14,7 +14,7 @@ namespace Kernel
 {
 	class PROCESS_HEADER_BLOCK;
 
-	typedef PROCESS_HEADER_BLOCK* ProcessHeaderRef;
+	typedef PROCESS_HEADER_BLOCK* PROCESS_HEADER_BLOCK_PTR;
 
 	/// @brief Access control class, which locks a task until one is done.
 	class Semaphore final
@@ -38,6 +38,6 @@ namespace Kernel
 		ZKA_COPY_DEFAULT(Semaphore);
 
 	private:
-		ProcessHeaderRef fLockingProcess{nullptr};
+		PROCESS_HEADER_BLOCK_PTR fLockingProcess{nullptr};
 	};
 } // namespace Kernel
diff --git a/dev/ZKA/KernelKit/ThreadLocalStorage.inl b/dev/ZKA/KernelKit/ThreadLocalStorage.inl
index 56244537..97480bdd 100644
--- a/dev/ZKA/KernelKit/ThreadLocalStorage.inl
+++ b/dev/ZKA/KernelKit/ThreadLocalStorage.inl
@@ -16,9 +16,8 @@ inline T* tls_new_ptr(void) noexcept
 {
 	using namespace Kernel;
 
-	MUST_PASS(ProcessScheduler::The().Leak().TheCurrent());
-
-	auto ref_process = ProcessScheduler::The().Leak().TheCurrent();
+	auto ref_process = ProcessScheduler::The().CurrentProcess();
+	MUST_PASS(ref_process);
 
 	T* pointer = (T*)ref_process.Leak().New(sizeof(T));
 	return pointer;
@@ -33,9 +32,9 @@ inline Kernel::Bool tls_delete_ptr(T* ptr) noexcept
 
 	using namespace Kernel;
 
-	MUST_PASS(ProcessScheduler::The().Leak().TheCurrent());
+	auto ref_process = ProcessScheduler::The().CurrentProcess();
+	MUST_PASS(ref_process);
 
-	auto ref_process = ProcessScheduler::The().Leak().TheCurrent();
 	return ref_process.Leak().Delete(ptr, sizeof(T));
 }
 
diff --git a/dev/ZKA/NewKit/Array.hxx b/dev/ZKA/NewKit/Array.hxx
index dcb6aede..22ee9f6a 100644
--- a/dev/ZKA/NewKit/Array.hxx
+++ b/dev/ZKA/NewKit/Array.hxx
@@ -37,9 +37,17 @@ namespace Kernel
 			return true;
 		}
 
-		SizeT Count() const
+		const SizeT Count()
 		{
-			return N;
+			SizeT count = 0;
+
+			for (SizeT i = 0; i < N; i++)
+			{
+				if (fArray[i])
+					++count;
+			}
+
+			return count;
 		}
 
 		const T* CData()
diff --git a/dev/ZKA/NewKit/NewKit.hxx b/dev/ZKA/NewKit/NewKit.hxx
index e7766bde..1daa6af2 100644
--- a/dev/ZKA/NewKit/NewKit.hxx
+++ b/dev/ZKA/NewKit/NewKit.hxx
@@ -18,5 +18,4 @@
 #include <NewKit/OwnPtr.hxx>
 #include <NewKit/Ref.hxx>
 #include <NewKit/Stream.hxx>
-#include <KernelKit/ProcessHeap.hxx>
 #include <NewKit/Utils.hxx>
diff --git a/dev/ZKA/NewKit/Ref.hxx b/dev/ZKA/NewKit/Ref.hxx
index f23cfc08..41f003be 100644
--- a/dev/ZKA/NewKit/Ref.hxx
+++ b/dev/ZKA/NewKit/Ref.hxx
@@ -37,7 +37,7 @@ namespace Kernel
 		}
 
 	public:
-		T& operator->() const
+		T operator->() const
 		{
 		    MUST_PASS(*fClass);
 			return *fClass;
diff --git a/dev/ZKA/Sources/CodeManager.cxx b/dev/ZKA/Sources/CodeManager.cxx
index 47625ac1..3dc08ca6 100644
--- a/dev/ZKA/Sources/CodeManager.cxx
+++ b/dev/ZKA/Sources/CodeManager.cxx
@@ -21,9 +21,8 @@ namespace Kernel
 
 		PROCESS_HEADER_BLOCK proc((VoidPtr)main);
 		proc.Kind = PROCESS_HEADER_BLOCK::kExeKind;
-		rt_copy_memory((VoidPtr)processName, proc.Name, rt_string_len(proc.Name));
-		proc.Image = (VoidPtr)main;
+		rt_copy_memory((VoidPtr)processName, proc.Name, rt_string_len(processName));
 
-		return ProcessScheduler::The().Leak().Add(proc);
+		return ProcessScheduler::The().Add(proc) == kErrorSuccess;
 	}
 } // namespace Kernel
diff --git a/dev/ZKA/Sources/DLLMain.cxx b/dev/ZKA/Sources/DLLMain.cxx
index 0cecc820..89ca0d3c 100644
--- a/dev/ZKA/Sources/DLLMain.cxx
+++ b/dev/ZKA/Sources/DLLMain.cxx
@@ -17,7 +17,6 @@
 #include <KernelKit/PEF.hxx>
 #include <KernelKit/PEFCodeManager.hxx>
 #include <KernelKit/ProcessScheduler.hxx>
-#include <KernelKit/ProcessHeap.hxx>
 #include <NewKit/Json.hxx>
 #include <NewKit/KernelCheck.hxx>
 #include <NewKit/String.hxx>
@@ -189,6 +188,8 @@ EXTERN_C Kernel::Void ke_dll_entrypoint(Kernel::Void)
 	Kernel::cProcessScheduler = nullptr;
 	Kernel::ProcessHelper::StartScheduling();
 
+	CG::CGDrawStringToWnd(cKernelWnd, "newoskrnl.dll: Starting ZKA System...", 30, 10, RGB(0, 0, 0));
+
 	Kernel::PEFLoader sys_user_drv(kSysDrv);
 
 	if (sys_user_drv.IsLoaded())
@@ -212,13 +213,14 @@ EXTERN_C Kernel::Void ke_dll_entrypoint(Kernel::Void)
 		CG::CGDrawStringToWnd(cKernelWnd, kSysDrv, 20, 10 + (FONT_SIZE_X * Kernel::rt_string_len("newoskrnl.dll: Missing catalog: ")), RGB(0, 0, 0));
 	}
 
-	CG::CGDrawStringToWnd(cKernelWnd, "newoskrnl.dll: Starting ZKA...", 30, 10, RGB(0, 0, 0));
-
-	Kernel::ProcessHelper::StartScheduling();
-	
 	Kernel::execute_from_image([]() -> void {
 	},
 							   "ZKA Logger");
 
-	Kernel::ProcessHelper::StartScheduling();
+	while (Yes)
+	{
+		Kernel::ProcessHelper::StartScheduling();
+	}
+
+	Kernel::ke_stop(RUNTIME_CHECK_BOOTSTRAP);
 }
diff --git a/dev/ZKA/Sources/Network/IPC.cxx b/dev/ZKA/Sources/Network/IPC.cxx
index 2ec50892..92476d9c 100644
--- a/dev/ZKA/Sources/Network/IPC.cxx
+++ b/dev/ZKA/Sources/Network/IPC.cxx
@@ -63,7 +63,7 @@ namespace Kernel
 		if (!pckt ||
 			!ipc_int_sanitize_packet(pckt))
 		{
-			ProcessScheduler::The().Leak().TheCurrent().Leak().Crash();
+			ProcessScheduler::The().CurrentProcess().Leak().Crash();
 			return false;
 		}
 
@@ -82,7 +82,7 @@ namespace Kernel
 		// crash process if the packet pointer of pointer is NULL.
 		if (!pckt_in)
 		{
-			ProcessScheduler::The().Leak().TheCurrent().Leak().Crash();
+			ProcessScheduler::The().CurrentProcess().Leak().Crash();
 			return false;
 		}
 
@@ -98,12 +98,12 @@ namespace Kernel
 
 			(*pckt_in)->IpcEndianess		= static_cast<UInt8>(endian);
 			(*pckt_in)->IpcPacketSize		= sizeof(IPC_MESSAGE_STRUCT);
-			(*pckt_in)->IpcFrom.ProcessID	= Kernel::ProcessScheduler::The().Leak().TheCurrent().Leak().ProcessId;
-			(*pckt_in)->IpcFrom.ProcessTeam = Kernel::ProcessScheduler::The().Leak().CurrentTeam().mTeamId;
+			(*pckt_in)->IpcFrom.ProcessID	= Kernel::ProcessScheduler::The().CurrentProcess().Leak().ProcessId;
+			(*pckt_in)->IpcFrom.ProcessTeam = Kernel::ProcessScheduler::The().CurrentTeam().mTeamId;
 			return true;
 		}
 
-		ProcessScheduler::The().Leak().TheCurrent().Leak().Crash();
+		ProcessScheduler::The().CurrentProcess().Leak().Crash();
 		return false;
 	}
 } // namespace Kernel
diff --git a/dev/ZKA/Sources/PEFCodeManager.cxx b/dev/ZKA/Sources/PEFCodeManager.cxx
index 1b4adcfc..cecc4820 100644
--- a/dev/ZKA/Sources/PEFCodeManager.cxx
+++ b/dev/ZKA/Sources/PEFCodeManager.cxx
@@ -79,12 +79,12 @@ namespace Kernel
 			return;
 		}
 
-		kcout << "CodeManagerPEF: Warning: Executable format error!\r";
 		fBad = true;
 
 		if (fCachedBlob)
 			mm_delete_ke_heap(fCachedBlob);
 
+		kcout << "CodeManagerPEF: Warning: Executable format error!\r";
 		fCachedBlob = nullptr;
 	}
 
@@ -200,11 +200,9 @@ namespace Kernel
 				return false;
 
 			PROCESS_HEADER_BLOCK	  proc(errOrStart.Leak().Leak());
-			Ref<PROCESS_HEADER_BLOCK> refProc = proc;
-
 			proc.Kind = procKind;
 
-			return ProcessScheduler::The().Leak().Add(refProc);
+			return ProcessScheduler::The().Add(proc);
 		}
 	} // namespace Utils
 
diff --git a/dev/ZKA/Sources/ProcessHeap.cxx b/dev/ZKA/Sources/ProcessHeap.cxx
deleted file mode 100644
index d501f31d..00000000
--- a/dev/ZKA/Sources/ProcessHeap.cxx
+++ /dev/null
@@ -1,277 +0,0 @@
-/* -------------------------------------------
-
-	Copyright ZKA Technologies.
-
-------------------------------------------- */
-
-#include <KernelKit/ProcessScheduler.hxx>
-#include <KernelKit/ProcessHeap.hxx>
-#include <NewKit/PageManager.hxx>
-
-#define cHeapHeaderPaddingSz (16U)
-
-/// @file ProcessHeap.cxx
-/// @brief User Heap Manager, Process heap allocator.
-/// @note if you want to look at the kernel allocator, please look for
-/// KernelHeap.cxx
-/// BUGS: 0
-
-namespace Kernel
-{
-	/**
-	 * @brief Process Heap Header
-	 * @note Allocated per process, it denotes the user's heap.
-	 */
-	struct PROCESS_HEAP_HEADER final
-	{
-		UInt32	fPageMagic;
-		Int32	fPageFlags;
-		Boolean fPageFree;
-		UIntPtr fPageVirtStart;
-		SizeT   fPageVirtSize;
-		UInt8	fPagePad[cHeapHeaderPaddingSz];
-	};
-
-	/// @brief PROCESS_HEAP_HEADER as pointer type.
-	typedef PROCESS_HEAP_HEADER* PROCESS_HEAP_HEADER_PTR;
-
-	/**
-	 * @brief Process heap class, takes care of allocating the process pools.
-	 * @note This rely on Virtual Memory! Consider adding good vmem support when
-	 * @note porting to a new arch.
-	 */
-	class ProcessHeapHelper final
-	{
-		ProcessHeapHelper() = delete;
-
-	public:
-		~ProcessHeapHelper() = default;
-
-	public:
-		STATIC SizeT& Count() noexcept
-		{
-			return s_NumPools;
-		}
-
-		STATIC Ref<Pmm>& Leak() noexcept
-		{
-			return s_Pmm;
-		}
-
-		STATIC Boolean& IsEnabled() noexcept
-		{
-			return s_PoolsAreEnabled;
-		}
-
-		STATIC MutableArray<Ref<PTEWrapper>>& The() noexcept
-		{
-			return s_Pool;
-		}
-
-	private:
-		STATIC Size s_NumPools;
-		STATIC Ref<Pmm> s_Pmm;
-
-	private:
-		STATIC Boolean s_PoolsAreEnabled;
-		STATIC MutableArray<Ref<PTEWrapper>> s_Pool;
-	};
-
-	//! declare fields
-
-	SizeT						  ProcessHeapHelper::s_NumPools = 0UL;
-	Ref<Pmm>					  ProcessHeapHelper::s_Pmm;
-	Boolean						  ProcessHeapHelper::s_PoolsAreEnabled = true;
-	MutableArray<Ref<PTEWrapper>> ProcessHeapHelper::s_Pool;
-
-	STATIC VoidPtr sched_find_unused_heap(Int32 flags, SizeT len);
-	STATIC Void	   sched_free_heap_internal(VoidPtr vaddr);
-	STATIC VoidPtr sched_make_heap_internal(VoidPtr vaddr, Int32 flags, SizeT len);
-	STATIC Boolean sched_check_and_free_heap(const SizeT& index, VoidPtr ptr);
-
-	/// @brief Find an unused heap header to allocate on.
-	/// @param flags the flags to use.
-	/// @return VoidPtr the heap pointer.
-	STATIC VoidPtr sched_find_unused_heap(Int32 flags, SizeT len)
-	{
-		SizeT index = 0UL;
-
-		while (true)
-		{
-			/* ************************************ */
-			/* allocate if it doesnt exist. */
-			/* ************************************ */
-			if (!ProcessHeapHelper::The()[index])
-			{
-				ProcessHeapHelper::The().Add(Kernel::Ref<Kernel::PTEWrapper>());
-			}
-
-			if (ProcessHeapHelper::The()[index] &&
-				!ProcessHeapHelper::The()[index].Leak().Leak().Present())
-			{
-				ProcessHeapHelper::Leak().Leak().TogglePresent(
-					ProcessHeapHelper::The()[index].Leak().Leak(), true);
-					
-				ProcessHeapHelper::Leak().Leak().ToggleUser(
-					ProcessHeapHelper::The()[index].Leak().Leak(), true);
-
-				kcout << "[sched_find_unused_heap] Done, trying to make a pool now...\r";
-
-				return sched_make_heap_internal(
-					(VoidPtr)ProcessHeapHelper::The()[index].Leak().Leak().VirtualAddress(),
-					flags, len);
-			}
-
-			++index;
-		}
-
-		return nullptr;
-	}
-
-	/// @brief Makes a new heap for the process to use.
-	/// @param virtual_address the virtual address of the process.
-	/// @param flags the flags.
-	/// @return
-	STATIC VoidPtr sched_make_heap_internal(VoidPtr virtual_address, Int32 flags, SizeT len_in_gb)
-	{
-		if (virtual_address)
-		{
-			PROCESS_HEAP_HEADER* process_heap_hdr = reinterpret_cast<PROCESS_HEAP_HEADER*>(virtual_address);
-
-			if (!process_heap_hdr->fPageFree)
-			{
-				kcout
-					<< "[sched_make_heap_internal] process_heap_hdr->fPageFree, HeapPtr already exists\n";
-				return nullptr;
-			}
-
-			process_heap_hdr->fPageFlags = flags;
-			process_heap_hdr->fPageMagic = kProcessHeapMag;
-			process_heap_hdr->fPageFree	= false;
-			process_heap_hdr->fPageVirtStart = (UIntPtr)virtual_address + sizeof(PROCESS_HEAP_HEADER);
-			process_heap_hdr->fPageVirtSize = len_in_gb;
-
-			kcout << "[sched_make_heap_internal] New allocation has been done, returning new chunk.\n";
-
-			return reinterpret_cast<VoidPtr>(
-				(reinterpret_cast<UIntPtr>(virtual_address) + sizeof(PROCESS_HEAP_HEADER)));
-		}
-
-		kcout << "[sched_make_heap_internal] Address is invalid";
-		return nullptr;
-	}
-
-	/// @brief Internally makrs the heap as free.
-	/// This is done by setting the fPageFree bit to true
-	/// @param virtual_address
-	/// @return
-	STATIC Void sched_free_heap_internal(VoidPtr virtual_address)
-	{
-		PROCESS_HEAP_HEADER* process_heap_hdr = reinterpret_cast<PROCESS_HEAP_HEADER*>(
-			reinterpret_cast<UIntPtr>(virtual_address) - sizeof(PROCESS_HEAP_HEADER));
-
-		if (process_heap_hdr->fPageMagic == kProcessHeapMag)
-		{
-			if (!process_heap_hdr->fPageFree)
-			{
-				ProcessScheduler::The().Leak().TheCurrent().Leak().Crash();
-				return;
-			}
-
-			process_heap_hdr->fPageFree	= true;
-			process_heap_hdr->fPageFlags = 0;
-
-			kcout << "[sched_free_heap_internal] Successfully marked header as free!\r";
-		}
-	}
-
-	/**
-	 * @brief Check for the ptr and frees it.
-	 *
-	 * @param index Where to look at.
-	 * @param ptr The ptr to check.
-	 * @return Boolean true if successful.
-	 */
-	STATIC Boolean sched_check_and_free_heap(const SizeT& index, VoidPtr ptr)
-	{
-		if (ProcessHeapHelper::The()[index])
-		{
-			// ErrorOr<>::operator Boolean
-			/// if (address matches)
-			///     -> Free heap.
-			if (ProcessHeapHelper::The()[index].Leak().Leak().VirtualAddress() ==
-				(UIntPtr)ptr)
-			{
-				ProcessHeapHelper::Leak().Leak().FreePage(
-					ProcessHeapHelper::The()[index].Leak().Leak());
-
-				--ProcessHeapHelper::Count();
-
-				sched_free_heap_internal(ptr);
-				ptr = nullptr;
-
-				return true;
-			}
-		}
-
-		return false;
-	}
-
-	/// @brief Creates a new pool pointer.
-	/// @param flags the flags attached to it.
-	/// @return a pool pointer with selected permissions.
-	VoidPtr sched_new_heap(Int32 flags, SizeT page_size)
-	{
-		if (!ProcessHeapHelper::IsEnabled())
-			return nullptr;
-
-		if (VoidPtr ret = sched_find_unused_heap(flags, page_size))
-			return ret;
-
-		// this wasn't set to true
-		auto ref_page = ProcessHeapHelper::Leak().Leak().RequestPage(
-			((flags & kProcessHeapUser)), (flags & kProcessHeapRw));
-
-		if (ref_page)
-		{
-			///! reserve page.
-			ProcessHeapHelper::The()[ProcessHeapHelper::Count()].Leak() = ref_page;
-			auto& ref												= ProcessHeapHelper::Count();
-
-			++ref; // increment the number of addresses we have now.
-
-			// finally make the pool address.
-			return sched_make_heap_internal(
-				reinterpret_cast<VoidPtr>(ref_page.Leak().VirtualAddress()), flags, page_size);
-		}
-
-		return nullptr;
-	}
-
-	/// @brief free a pool pointer.
-	/// @param ptr The pool pointer to free.
-	/// @return status code
-	Int32 sched_free_heap(VoidPtr ptr)
-	{
-		if (!ProcessHeapHelper::IsEnabled())
-			return -1;
-
-		if (ptr)
-		{
-			SizeT base = ProcessHeapHelper::Count();
-
-			if (sched_check_and_free_heap(base, ptr))
-				return 0;
-
-			for (SizeT index = 0; index < ProcessHeapHelper::The().Count(); ++index)
-			{
-				if (sched_check_and_free_heap(index, ptr))
-					return 0;
-
-				--base;
-			}
-		}
-
-		return -1;
-	}
-} // namespace Kernel
diff --git a/dev/ZKA/Sources/ProcessScheduler.cxx b/dev/ZKA/Sources/ProcessScheduler.cxx
index 579294fb..82c1cf57 100644
--- a/dev/ZKA/Sources/ProcessScheduler.cxx
+++ b/dev/ZKA/Sources/ProcessScheduler.cxx
@@ -211,71 +211,71 @@ namespace Kernel
 	/// @brief Add process to list.
 	/// @param process the process *Ref* class.
 	/// @return the process index inside the team.
-	SizeT ProcessScheduler::Add(Ref<PROCESS_HEADER_BLOCK> process)
+	SizeT ProcessScheduler::Add(PROCESS_HEADER_BLOCK& process)
 	{
-		if (!process.Leak().Image)
+		if (!process.Image)
 		{
 			return -kErrorInvalidData;
 		}
 
-		if (mTeam.AsArray().Count() > kSchedProcessLimitPerTeam)
-			return -kErrorOutOfTeamSlot;
-
 		kcout << "ProcessScheduler: Adding process to team...\r";
 
 		// Create heap according to type of process.
-		if (process.Leak().Kind == PROCESS_HEADER_BLOCK::kExeKind)
+		if (process.Kind == PROCESS_HEADER_BLOCK::kExeKind)
 		{
-			process.Leak().HeapPtr = mm_new_ke_heap(process.Leak().SizeMemory, true, true);
+			process.HeapPtr = mm_new_ke_heap(process.SizeMemory, true, true);
 		}
-		else if (process.Leak().Kind == PROCESS_HEADER_BLOCK::kSharedObjectKind)
+		else if (process.Kind == PROCESS_HEADER_BLOCK::kSharedObjectKind)
 		{
-			process.Leak().DLLPtr = rtl_init_shared_object(&process.Leak());
-			process.Leak().HeapPtr = mm_new_ke_heap(process.Leak().SizeMemory, true, true);
+			process.DLLPtr	= rtl_init_shared_object(&process);
+			process.HeapPtr = mm_new_ke_heap(process.SizeMemory, true, true);
 		}
 		else
 		{
 			// Something went wrong, do not continue, process may be incorrect.
-			process.Leak().Crash();
+			process.Crash();
 			return -kErrorProcessFault;
 		}
 
-		process.Leak().StackFrame = reinterpret_cast<HAL::StackFrame*>(
+		process.StackFrame = reinterpret_cast<HAL::StackFrame*>(
 			mm_new_ke_heap(sizeof(HAL::StackFrame), Yes, Yes));
 
-		MUST_PASS(process.Leak().StackFrame);
+		MUST_PASS(process.StackFrame);
 
-		if (process.Leak().Image)
+		if (process.Image)
 		{
-			process.Leak().StackFrame->BP = reinterpret_cast<HAL::Reg>(process.Leak().Image);
+			process.StackFrame->BP = reinterpret_cast<HAL::Reg>(process.Image);
 		}
 		else
 		{
-			if (process.Leak().Kind != PROCESS_HEADER_BLOCK::kSharedObjectKind)
+			if (process.Kind != PROCESS_HEADER_BLOCK::kSharedObjectKind)
 			{
-				process.Leak().Crash();
+				process.Crash();
 				return -kErrorProcessFault;
 			}
 		}
 
-		if (!process.Leak().StackFrame->SP)
-			process.Leak().StackFrame->SP = reinterpret_cast<HAL::Reg>(mm_new_ke_heap(sizeof(UInt8) * 8196, Yes, Yes));
+		if (!process.StackFrame->SP)
+			process.StackFrame->SP = reinterpret_cast<HAL::Reg>(mm_new_ke_heap(sizeof(UInt8) * 8196, Yes, Yes));
+
+		process.Status = ProcessStatus::kStarting;
+
+		process.ProcessId = (mTeam.mCurrentProcess);
 
-		process.Leak().Status = ProcessStatus::kStarting;
+		++mTeam.mProcessAmount;
 
-		process.Leak().ProcessId  = (mTeam.AsArray().Count() - 1);
-		process.Leak().HeapCursor = process.Leak().HeapPtr;
+		process.HeapCursor = process.HeapPtr;
 
-		mTeam.AsArray()[process.Leak().ProcessId] = process.Leak();
+		mTeam.AsArray()[process.ProcessId] = process;
 
 		kcout << "ProcessScheduler: Adding process to team [ OK ]...\r";
 
-		return (mTeam.AsArray().Count() - 1);
+		return process.ProcessId;
 	}
 
 	/***********************************************************************************/
 
-	Ref<ProcessScheduler> ProcessScheduler::The()
+	ProcessScheduler& ProcessScheduler::The()
 	{
 		MUST_PASS(cProcessScheduler);
 		return *cProcessScheduler;
@@ -287,7 +287,7 @@ namespace Kernel
 	/// @param processSlot process slot inside team.
 	/// @retval true process was removed.
 	/// @retval false process doesn't exist in team.
-	Bool ProcessScheduler::Remove(SizeT processSlot)
+	Bool ProcessScheduler::Remove(ProcessID processSlot)
 	{
 		// check if process is within range.
 		if (processSlot > mTeam.AsArray().Count())
@@ -299,6 +299,7 @@ namespace Kernel
 
 		kcout << "ProcessScheduler: Removing process...\r";
 
+		--mTeam.mProcessAmount;
 		mTeam.AsArray()[processSlot].Status = ProcessStatus::kDead;
 		return true;
 	}
@@ -349,7 +350,7 @@ namespace Kernel
 
 	/// @brief Gets current running process.
 	/// @return
-	Ref<PROCESS_HEADER_BLOCK>& ProcessScheduler::TheCurrent()
+	Ref<PROCESS_HEADER_BLOCK>& ProcessScheduler::CurrentProcess()
 	{
 		return mTeam.AsRef();
 	}
@@ -359,7 +360,7 @@ namespace Kernel
 	PID& ProcessHelper::TheCurrentPID()
 	{
 		kcout << "ProcessHelper::TheCurrentPID: Leaking ProcessId...\r";
-		return cProcessScheduler->TheCurrent().Leak().ProcessId;
+		return cProcessScheduler->CurrentProcess().Leak().ProcessId;
 	}
 
 	/// @brief Check if process can be schedulded.
@@ -377,16 +378,16 @@ namespace Kernel
 			if (auto start = process.DLLPtr->Load<VoidPtr>(kPefStart, rt_string_len(kPefStart), kPefCode);
 				start)
 			{
-				process.Image		  = start;
+				process.Image		   = start;
 				process.StackFrame->BP = reinterpret_cast<HAL::Reg>(start);
 			}
 		}
 
-		return process.PTime > 0;
+		return process.PTime < 0;
 	}
 
 	/**
-	 * @brief Spin scheduler class.
+	 * @brief Scheduler helper class.
 	 */
 
 	SizeT ProcessHelper::StartScheduling()
diff --git a/dev/ZKA/Sources/ProcessTeam.cxx b/dev/ZKA/Sources/ProcessTeam.cxx
index c6a26275..58a639f6 100644
--- a/dev/ZKA/Sources/ProcessTeam.cxx
+++ b/dev/ZKA/Sources/ProcessTeam.cxx
@@ -22,7 +22,7 @@ namespace Kernel
 
 	/// @brief Get team ID.
 	/// @return The team's ID.
-	UInt64& ProcessTeam::Id() noexcept
+	ProcessID& ProcessTeam::Id() noexcept
 	{
 		return mTeamId;
 	}