FIX: Scheduler improvements, MM improvements, worked on a tiny bmp allocator for pages.

Signed-off-by: Amlal <amlal@el-mahrouss-logic.com>

15 files changed, 209 insertions, 111 deletions

diff --git a/dev/HPFS/Sources/IFSMain.cxx b/dev/HPFS/Sources/IFSMain.cxx
index d107db2a..c2ae5b0a 100644
--- a/dev/HPFS/Sources/IFSMain.cxx
+++ b/dev/HPFS/Sources/IFSMain.cxx
@@ -8,9 +8,13 @@
 ------------------------------------------- */
 
 #include <HPFS/Defines.hxx>
+#include <DDK/KernelStd.h>
 
 /** @brief HPFS IFS main. */
-HPFS_INT32 IFSStart(HPFS_VOID)
+HPFS_INT32 ModuleMain(HPFS_VOID)
 {
+    auto ifs_handle = KernelGetProperty(0, "\\.\\IFSObject");
+    // TODO: Register IFS...
+
     return 0;
 }
diff --git a/dev/HPFS/hpfs.json b/dev/HPFS/hpfs.json
index a7ba778e..2b08f057 100644
--- a/dev/HPFS/hpfs.json
+++ b/dev/HPFS/hpfs.json
@@ -14,6 +14,7 @@
   ],
   "cpp_macros": [
     "__HPFS_IMPL__",
+    "__NEWOSKRNL__",
     "cHPFSVersion=0x0100",
     "cHPFSVersionHighest=0x0100",
     "cHPFSVersionLowest=0x0100"
diff --git a/dev/ZKA/HALKit/AMD64/HalBMPMgr.cxx b/dev/ZKA/HALKit/AMD64/HalBMPMgr.cxx
index cb302f93..e12f3765 100644
--- a/dev/ZKA/HALKit/AMD64/HalBMPMgr.cxx
+++ b/dev/ZKA/HALKit/AMD64/HalBMPMgr.cxx
@@ -54,10 +54,10 @@ namespace Kernel
 								kcout << "Address Of BMP: " << hex_number((UIntPtr)ptr_bit_set) << endl;
 
 								if (rw)
-									mm_map_page(base_ptr, 0, eFlagsRw | eFlagsPresent);
+									mm_map_page(base_ptr, eFlagsRw | eFlagsPresent);
 
 								if (user)
-									mm_map_page(base_ptr, 0, eFlagsRw | eFlagsUser | eFlagsPresent);
+									mm_map_page(base_ptr, eFlagsUser | eFlagsPresent);
 
 								return (VoidPtr)ptr_bit_set;
 							}
@@ -80,10 +80,10 @@ namespace Kernel
 							kcout << "Address Of BMP: " << hex_number((UIntPtr)ptr_bit_set) << endl;
 
 							if (rw)
-								mm_map_page(base_ptr, 0, eFlagsRw | eFlagsPresent);
+								mm_map_page(base_ptr, eFlagsRw | eFlagsPresent);
 
 							if (user)
-								mm_map_page(base_ptr, 0, eFlagsRw | eFlagsUser | eFlagsPresent);
+								mm_map_page(base_ptr, eFlagsUser | eFlagsPresent);
 
 							return (VoidPtr)ptr_bit_set;
 						}
@@ -141,7 +141,7 @@ namespace Kernel
 			ptr_bit_set[0] = cBitMpMagic;
 			ptr_bit_set[2] = No;
 
-			mm_map_page(page_ptr, 0, 0);
+			mm_map_page(page_ptr, ~eFlagsPresent);
 
 			return true;
 		}
diff --git a/dev/ZKA/HALKit/AMD64/HalInterruptAPI.asm b/dev/ZKA/HALKit/AMD64/HalInterruptAPI.asm
index 56853441..e2dec1f9 100644
--- a/dev/ZKA/HALKit/AMD64/HalInterruptAPI.asm
+++ b/dev/ZKA/HALKit/AMD64/HalInterruptAPI.asm
@@ -17,14 +17,14 @@
 global __ZKA_INT_%1
 __ZKA_INT_%1:
     cld
-    iretq
+    o64 iret
 %endmacro
 
 %macro IntNormal 1
 global __ZKA_INT_%1
 __ZKA_INT_%1:
     cld
-    iretq
+    o64 iret
 %endmacro
 
 ; This file handles the core interrupt table
@@ -62,7 +62,7 @@ __ZKA_INT_6:
     pop rax
 
     sti
-    iretq
+    o64 iret
 
 IntNormal 7
 
@@ -78,7 +78,7 @@ __ZKA_INT_8:
     pop rax
 
     sti
-    iretq
+    o64 iret
 
 IntNormal 9
 IntExp   10
@@ -97,7 +97,7 @@ __ZKA_INT_13:
     pop rax
 
     sti
-    iretq
+    o64 iret
 
 __ZKA_INT_14:
     cli
@@ -110,7 +110,7 @@ __ZKA_INT_14:
     pop rax
 
     sti
-    iretq
+    o64 iret
 
 IntNormal 15
 IntNormal 16
@@ -152,9 +152,27 @@ IntNormal 47
 IntNormal 48
 IntNormal 49
 
+[extern hal_system_call_enter]
 [extern hal_kernel_call_enter]
 
-IntNormal 50
+__ZKA_INT_50:
+    cli
+
+    push r8
+    push r9
+    push r10
+    push rsp
+
+    jmp hal_system_call_enter
+
+    add rsp, 16
+    pop rsp
+    pop r10
+    pop r9
+    pop r8
+
+    sti
+    o64 iret
 
 __ZKA_INT_51:
     cli
@@ -174,7 +192,7 @@ __ZKA_INT_51:
     pop rcx
 
     sti
-    iretq
+    o64 iret
 
 [extern hal_on_ap_startup]
 
diff --git a/dev/ZKA/HALKit/AMD64/HalKernelMain.cxx b/dev/ZKA/HALKit/AMD64/HalKernelMain.cxx
index e59eb7cf..7f77824e 100644
--- a/dev/ZKA/HALKit/AMD64/HalKernelMain.cxx
+++ b/dev/ZKA/HALKit/AMD64/HalKernelMain.cxx
@@ -56,8 +56,9 @@ namespace Kernel::HAL
 Kernel::Property cKernelVersion;
 Kernel::User	 cUserSuper{Kernel::RingKind::kRingSuperUser, kSuperUser};
 
-EXTERN_C ATTRIBUTE(naked) void mp_user_switch_proc(void);
-EXTERN_C Kernel::UInt8* mp_user_switch_proc_end;
+EXTERN_C Kernel::UInt8* mp_user_switch_proc;
+EXTERN_C Kernel::UInt8* mp_user_switch_proc_stack_end;
+EXTERN_C Kernel::VoidPtr mp_user_switch_proc_real;
 
 EXTERN_C Kernel::VoidPtr kInterruptVectorTable[];
 EXTERN_C Kernel::Void hal_real_init(Kernel::Void) noexcept;
@@ -129,8 +130,8 @@ EXTERN_C Kernel::Void hal_real_init(Kernel::Void) noexcept
 
 	MUST_PASS(fs);
 
-	Kernel::HAL::mm_map_page((Kernel::VoidPtr)mp_user_switch_proc, 0, Kernel::HAL::eFlagsUser | Kernel::HAL::eFlagsRw  | Kernel::HAL::eFlagsPresent);
-	Kernel::HAL::mm_map_page((Kernel::VoidPtr)mp_user_switch_proc_end, 0, Kernel::HAL::eFlagsUser | Kernel::HAL::eFlagsRw | Kernel::HAL::eFlagsPresent);
+	Kernel::HAL::mm_map_page((Kernel::VoidPtr)mp_user_switch_proc, Kernel::HAL::eFlagsUser | Kernel::HAL::eFlagsRw | Kernel::HAL::eFlagsPresent);
+	Kernel::HAL::mm_map_page((Kernel::VoidPtr)mp_user_switch_proc_stack_end, Kernel::HAL::eFlagsUser | Kernel::HAL::eFlagsRw | Kernel::HAL::eFlagsPresent);
 
 	Kernel::NewFilesystemMgr::Mount(fs);
 
diff --git a/dev/ZKA/HALKit/AMD64/HalMPContextSwitch.asm b/dev/ZKA/HALKit/AMD64/HalMPContextSwitch.asm
index 945830e2..4251f232 100644
--- a/dev/ZKA/HALKit/AMD64/HalMPContextSwitch.asm
+++ b/dev/ZKA/HALKit/AMD64/HalMPContextSwitch.asm
@@ -12,16 +12,18 @@
 [global mp_do_user_switch]
 [global mp_do_context_switch_pre]
 [global mp_user_switch_proc]
-[global mp_user_switch_proc_end]
+[global mp_user_switch_proc_real]
+[global mp_user_switch_proc_stack_end]
 
 section .text
 
 ;; @brief Switch to user mode.
 mp_do_user_switch:
     mov rbp, rsp
-    mov rsp, mp_user_switch_proc_end
+    mov rsp, mp_user_switch_proc_stack_end
 
-    invlpg [0]
+    mov rdx, mp_user_switch_proc
+    invlpg [rdx]
 
     mov ax, 0x18 | 3
     mov ds, ax
@@ -31,7 +33,7 @@ mp_do_user_switch:
 
     push 0x18 | 3
 
-    mov rax, mp_user_switch_proc_end
+    mov rax, mp_user_switch_proc_stack_end
     push rax
 
     o64 pushf
@@ -45,11 +47,13 @@ mp_do_user_switch:
 
 section .bss
 
-mp_user_switch_proc_begin:
+mp_user_switch_proc_stack_begin:
     resb 4*4096
-mp_user_switch_proc_end:
+mp_user_switch_proc_stack_end:
 
 section .text
 
 mp_user_switch_proc:
+    nop
     jmp $
+mp_user_switch_proc_end:
diff --git a/dev/ZKA/HALKit/AMD64/HalPageAlloc.hxx b/dev/ZKA/HALKit/AMD64/HalPageAlloc.hxx
index 3cd7ab0f..c5bede49 100644
--- a/dev/ZKA/HALKit/AMD64/HalPageAlloc.hxx
+++ b/dev/ZKA/HALKit/AMD64/HalPageAlloc.hxx
@@ -14,17 +14,17 @@
 
 #include <NewKit/Defines.hxx>
 
-#ifndef kPTEMax
-#define kPTEMax (0x200)
-#endif //! kPTEMax
+#ifndef kPageMax
+#define kPageMax (0x200)
+#endif //! kPageMax
 
-#ifndef kPTEAlign
-#define kPTEAlign (0x1000)
-#endif //! kPTEAlign
+#ifndef kPageAlign
+#define kPageAlign (0x1000)
+#endif //! kPageAlign
 
-#ifndef kPTESize
-#define kPTESize (0x1000)
-#endif // !kPTESize
+#ifndef kPageSize
+#define kPageSize (0x200)
+#endif // !kPageSize
 
 #ifndef kAlign
 #define kAlign __BIGGEST_ALIGNMENT__
@@ -85,7 +85,7 @@ namespace Kernel::HAL
 
 	struct ALIGN(0x08) ZKA_PDE final
 	{
-		ZKA_PTE ALIGN(kPTEAlign) Pte[kPTEMax];
+		ZKA_PTE ALIGN(kPageAlign) Pte[kPageMax];
 	};
 
 	auto mm_alloc_bitmap(Boolean rw, Boolean user, SizeT size) -> VoidPtr;
diff --git a/dev/ZKA/HALKit/AMD64/HalProcessorMgr.cxx b/dev/ZKA/HALKit/AMD64/HalProcessorMgr.cxx
index 53b8b0b0..1df0fd5c 100644
--- a/dev/ZKA/HALKit/AMD64/HalProcessorMgr.cxx
+++ b/dev/ZKA/HALKit/AMD64/HalProcessorMgr.cxx
@@ -14,73 +14,137 @@
  * @brief CPU Processor managers.
  */
 
+#define cPageSz		kPageSize				// 4KB pages
+#define cTotalPgMem gib_cast(16)			// 16MB total memory
+#define cTotalPages (cTotalPgMem / cPageSz) // Total number of pages
+#define cBmpPgSz	(cTotalPages / 8)		// 1 bit per page in the bitmap
+
 namespace Kernel::HAL
 {
-	/// @brief Set a PTE from pd_base.
+	namespace MM
+	{
+		UInt8 cPageBitMp[cBmpPgSz] = {0}; // Bitmap to track free/used pages
+
+		void pg_set_used(Int64 page_index)
+		{
+			cPageBitMp[page_index / 8] |= (1 << (page_index % 8));
+		}
+
+		void pg_set_free(Int64 page_index)
+		{
+			cPageBitMp[page_index / 8] &= ~(1 << (page_index % 8));
+		}
+
+		int pg_is_free(Int64 page_index)
+		{
+			return !(cPageBitMp[page_index / 8] & (1 << (page_index % 8)));
+		}
+
+		VoidPtr pg_allocate()
+		{
+			for (SizeT i = 0; i < cTotalPages; i++)
+			{
+				if (pg_is_free(i))
+				{
+					pg_set_used(i);
+					kcout << "Page has been allocated at index: " << number(i) << endl;
+
+					return (VoidPtr)(i * cPageSz); // Return physical address of the page
+				}
+			}
+
+			return nullptr; // No free page found
+		}
+
+		void pg_delete(void* addr)
+		{
+			Int64 page_index = (UIntPtr)addr / cPageSz;
+			kcout << "Page has been freed at: " << number(page_index) << endl;
+
+			pg_set_free(page_index);
+		}
+
+	} // namespace MM
+
+	/// @brief Maps or allocates a page from virt_addr.
 	/// @param virt_addr a valid virtual address.
 	/// @param phys_addr point to physical address.
 	/// @param flags the flags to put on the page.
 	/// @return Status code of page manip.
-	EXTERN_C Int32 mm_map_page(VoidPtr virt_addr, VoidPtr phys_addr, UInt32 flags)
+	EXTERN_C Int32 mm_map_page(VoidPtr p_virt_addr, UInt32 flags)
 	{
 		rt_cli();
 
-		const auto cPAddrMask = 0x000ffffffffff000;
-		const auto cFlagsMask = 0xFFF;
+		const auto cPageMask = 0xFFFF;
+
+		volatile UIntPtr* pml4_base = (volatile UIntPtr*)(hal_read_cr3());
 
-		VoidPtr pml4_base = hal_read_cr3();
+		UIntPtr virt_addr = (UIntPtr)p_virt_addr;
 
-		UIntPtr pd_idx	= ((UIntPtr)virt_addr >> 22);
-		UIntPtr pte_idx = ((UIntPtr)virt_addr >> 12) & 0x03FF;
+		UInt16 pml4_index = (virt_addr >> 39) & 0x1FF;
+		UInt16 pdpt_index = (virt_addr >> 30) & 0x1FF;
+		UInt16 pd_index	  = (virt_addr >> 21) & 0x1FF;
+		UInt16 pt_index	  = (virt_addr >> 12) & 0x1FF;
+		UInt16 offset	  = virt_addr & 0xFFF;
 
-		// Now get pd_entry
-		volatile UInt64* pd_entry = (volatile UInt64*)(((UInt64)pml4_base) + (pd_idx * kPTEAlign));
+		const auto cIndexAlign = kPageAlign;
 
-		UInt64 pt_base = *pd_entry & ~0xFFF; // Remove flags
+		// Now get pml4_entry
+		volatile UIntPtr* pml4_entry = (volatile UInt64*)((pml4_base[pml4_index + cIndexAlign]));
 
-		switch ((UIntPtr)phys_addr)
+		if (!(*pml4_entry & eFlagsPresent))
 		{
-		case kBadAddress: {
-			phys_addr = (VoidPtr)((pt_base & cPAddrMask) + ((UIntPtr)virt_addr & cFlagsMask));
-			break;
+			auto pml_addr = MM::pg_allocate();
+			*pml4_entry	  = (UIntPtr)pml_addr | eFlagsPresent | eFlagsRw;
 		}
-		default: {
-			break;
+
+		volatile UIntPtr* pdpt_entry = (volatile UIntPtr*)(pml4_entry[pdpt_index + cIndexAlign]);
+
+		if (!(*pdpt_entry & eFlagsPresent))
+		{
+			auto pdpt_addr = MM::pg_allocate();
+			*pdpt_entry	   = (UIntPtr)pdpt_addr | eFlagsPresent | eFlagsRw;
 		}
+
+		volatile UIntPtr* pd_entry = (volatile UIntPtr*)(pdpt_entry[pd_index + cIndexAlign]);
+
+		if (!(*pd_entry & eFlagsPresent))
+		{
+			auto pd_addr = MM::pg_allocate();
+			*pd_entry	 = (UIntPtr)pd_addr | eFlagsPresent | eFlagsRw;
 		}
 
-		// And then PTE
-		volatile UIntPtr* pt_entry = (volatile UIntPtr*)(pt_base + (pte_idx * kPTEAlign));
+		volatile UIntPtr* pt_entry = (volatile UIntPtr*)(pd_entry[pt_index + cIndexAlign]);
 
 		if (!(*pt_entry & eFlagsPresent))
 		{
-			*pt_entry = ((UIntPtr)phys_addr) | (flags & 0xFFF) | eFlagsPresent;
+			PTE* frame = (PTE*)pt_entry;
 
-			hal_invl_tlb((VoidPtr)virt_addr);
+			MM::pg_delete((VoidPtr)frame->PhysicalAddress);
 
-			kcout << "=================================================\r";
-			kcout << "Post page allocation.\r";
-			kcout << "=================================================\r";
+			auto pt_addr = MM::pg_allocate();
+			*pt_entry	 = (UIntPtr)pt_addr | eFlagsPresent | flags;
 
-			kcout << (*pt_entry & eFlagsPresent ? "Page Present." : "Page Not Present.") << endl;
-			kcout << (*pt_entry & eFlagsRw ? "Page RW." : "Page Not RW.") << endl;
-			kcout << (*pt_entry & eFlagsUser ? "Page User." : "Page Not User.") << endl;
+			kcout << (frame->Present ? "Page Present." : "Page Not Present.") << endl;
+			kcout << (frame->Rw ? "Page RW." : "Page Not RW.") << endl;
+			kcout << (frame->User ? "Page User." : "Page Not User.") << endl;
 
-			rt_sti();
-			return 0;
+			kcout << "Physical Address: " << number(frame->PhysicalAddress) << endl;
 		}
+		else
+		{
+			PTE* frame = (PTE*)pt_entry;
 
-		*pt_entry = ((UIntPtr)phys_addr) | (flags & 0xFFF) | eFlagsPresent;
+			*pt_entry = (UIntPtr)(frame->PhysicalAddress / cPageSz) | flags;
 
-		hal_invl_tlb((VoidPtr)virt_addr);
+			kcout << (frame->Present ? "Page Present." : "Page Not Present.") << endl;
+			kcout << (frame->Rw ? "Page RW." : "Page Not RW.") << endl;
+			kcout << (frame->User ? "Page User." : "Page Not User.") << endl;
 
-		kcout << "=================================================\r";
-		kcout << "Post page change.\r";
-		kcout << "=================================================\r";
+			kcout << "Physical Address: " << number(frame->PhysicalAddress) << endl;
+		}
 
-		kcout << (*pt_entry & eFlagsPresent ? "Page Present." : "Page Not Present.") << endl;
-		kcout << (*pt_entry & eFlagsRw ? "Page RW." : "Page Not RW.") << endl;
-		kcout << (*pt_entry & eFlagsUser ? "Page User." : "Page Not User.") << endl;
+		hal_invl_tlb(p_virt_addr);
 
 		rt_sti();
 		return 0;
diff --git a/dev/ZKA/HALKit/AMD64/Processor.hxx b/dev/ZKA/HALKit/AMD64/Processor.hxx
index 90310aa1..8463550c 100644
--- a/dev/ZKA/HALKit/AMD64/Processor.hxx
+++ b/dev/ZKA/HALKit/AMD64/Processor.hxx
@@ -55,16 +55,10 @@ namespace Kernel::HAL
 	/// @brief Virtual memory flags.
 	enum
 	{
-		eFlagsPresent = 1 << 0,
-		eFlagsRw	  = 1 << 1,
-		eFlagsUser	  = 1 << 2,
-		eFlagsWt	  = 1 << 3,
-		eFlagsNoCache = 1 << 4,
-		eFlagsAccess  = 1 << 5,
-		eFlagsDirty	  = 1 << 6,
-		eFlagsHuge	  = 1 << 7,
-		eFlagsGlobal  = 1 << 8,
-		eFlagsCount	  = 8,
+		eFlagsPresent = 1,
+		eFlagsRw	  = 2,
+		eFlagsUser	  = 4,
+		eFlagsCount	  = 3,
 	};
 
 	/// @brief Set a PTE from pd_base.
@@ -72,7 +66,7 @@ namespace Kernel::HAL
 	/// @param phys_addr point to physical address.
 	/// @param flags the flags to put on the page.
 	/// @return Status code of page manip.
-	EXTERN_C Int32 mm_map_page(VoidPtr virt_addr, VoidPtr phys_addr, UInt32 flags);
+	EXTERN_C Int32 mm_map_page(VoidPtr virt_addr, UInt32 flags);
 
 	EXTERN_C UChar	In8(UInt16 port);
 	EXTERN_C UShort In16(UInt16 port);
diff --git a/dev/ZKA/HALKit/ARM64/HalPageAlloc.hxx b/dev/ZKA/HALKit/ARM64/HalPageAlloc.hxx
index ab77f1d0..6cfeacf3 100644
--- a/dev/ZKA/HALKit/ARM64/HalPageAlloc.hxx
+++ b/dev/ZKA/HALKit/ARM64/HalPageAlloc.hxx
@@ -14,17 +14,17 @@
 
 #include <NewKit/Defines.hxx>
 
-#ifndef kPTEMax
-#define kPTEMax (0x200)
-#endif //! kPTEMax
+#ifndef kPageMax
+#define kPageMax (0x200)
+#endif //! kPageMax
 
-#ifndef kPTEAlign
-#define kPTEAlign (0x1000)
-#endif //! kPTEAlign
+#ifndef kPageAlign
+#define kPageAlign (0x1000)
+#endif //! kPageAlign
 
-#ifndef kPTESize
-#define kPTESize (0x1000)
-#endif // !kPTESize
+#ifndef kPageSize
+#define kPageSize (0x1000)
+#endif // !kPageSize
 
 //! short format address range
 
@@ -93,7 +93,7 @@ namespace Kernel::HAL
 
 	struct PageDirectory64 final
 	{
-		LongDescLevel3 ALIGN(kPTEAlign) Pte[kPTEMax];
+		LongDescLevel3 ALIGN(kPageAlign) Pte[kPageMax];
 	};
 
 	VoidPtr mm_alloc_bitmap(Boolean rw, Boolean user, SizeT size);
diff --git a/dev/ZKA/HALKit/ARM64/Processor.hxx b/dev/ZKA/HALKit/ARM64/Processor.hxx
index ad2bdc7b..ab864577 100644
--- a/dev/ZKA/HALKit/ARM64/Processor.hxx
+++ b/dev/ZKA/HALKit/ARM64/Processor.hxx
@@ -11,7 +11,7 @@
 #include <NewKit/Utils.hxx>
 #include <FirmwareKit/Handover.hxx>
 
-#define kPTESize 512 /* 64-bit PT */
+#define kPageSize 512 /* 64-bit PT */
 
 #define kCPUBackendName "ARMv8"
 
diff --git a/dev/ZKA/KernelKit/HardwareThreadScheduler.hxx b/dev/ZKA/KernelKit/HardwareThreadScheduler.hxx
index e4b83659..193f5bff 100644
--- a/dev/ZKA/KernelKit/HardwareThreadScheduler.hxx
+++ b/dev/ZKA/KernelKit/HardwareThreadScheduler.hxx
@@ -73,11 +73,13 @@ namespace Kernel
 		ThreadKind		   fKind{ThreadKind::kHartStandard};
 		ThreadID		   fID{0};
 		ProcessID		   fSourcePID{-1};
-		bool			   fWakeup{false};
-		bool			   fBusy{false};
+		Bool			   fWakeup{false};
+		Bool			   fBusy{false};
+		UInt64			   fPTime{0};
 
 	private:
 		friend class HardwareThreadScheduler;
+		friend class UserProcessHelper;
 	};
 
 	///
diff --git a/dev/ZKA/Sources/HardwareThreadScheduler.cxx b/dev/ZKA/Sources/HardwareThreadScheduler.cxx
index e5947357..22a69b9b 100644
--- a/dev/ZKA/Sources/HardwareThreadScheduler.cxx
+++ b/dev/ZKA/Sources/HardwareThreadScheduler.cxx
@@ -43,6 +43,14 @@ namespace Kernel
 	//! @brief is the thread busy?
 	Bool HardwareThread::IsBusy() noexcept
 	{
+		STATIC Int64 busy_timer = 0U;
+
+		if (busy_timer > this->fPTime)
+		{
+			busy_timer = 0U;
+			fBusy	   = No;
+		}
+
 		return fBusy;
 	}
 
@@ -95,16 +103,17 @@ namespace Kernel
 		if (!this->IsWakeup())
 			return No;
 
-		fStack = frame;
-
 		if (this->IsBusy())
-			return false;
+			return No;
 
-		kcout << "Registering process bank...\r";
+		fStack = frame;
+
+		kcout << "Trying to register progress...\r";
 
-		this->Busy(true);
 		Bool ret = mp_register_process(image, stack_ptr, fStack);
-		this->Busy(false);
+
+		if (ret)
+			this->Busy(true);
 
 		return ret;
 	}
diff --git a/dev/ZKA/Sources/Pmm.cxx b/dev/ZKA/Sources/Pmm.cxx
index 58335a2b..394b634c 100644
--- a/dev/ZKA/Sources/Pmm.cxx
+++ b/dev/ZKA/Sources/Pmm.cxx
@@ -31,7 +31,7 @@ namespace Kernel
 	/// @param readWrite is it r/w?
 	Ref<PTEWrapper> Pmm::RequestPage(Boolean user, Boolean readWrite)
 	{
-		PTEWrapper pt = fPageMgr.Leak().Request(user, readWrite, false, kPTESize);
+		PTEWrapper pt = fPageMgr.Leak().Request(user, readWrite, false, kPageSize);
 
 		if (pt.fPresent)
 		{
diff --git a/dev/ZKA/Sources/UserProcessScheduler.cxx b/dev/ZKA/Sources/UserProcessScheduler.cxx
index 721bd02f..00f314d1 100644
--- a/dev/ZKA/Sources/UserProcessScheduler.cxx
+++ b/dev/ZKA/Sources/UserProcessScheduler.cxx
@@ -348,11 +348,6 @@ namespace Kernel
 					continue;
 				}
 			}
-			else
-			{
-				// otherwise increment the P-time.
-				--process.PTime;
-			}
 		}
 
 		kcout << "Scheduled Process Count: " << number(process_index) << endl;
@@ -390,15 +385,17 @@ namespace Kernel
 	/// @retval false cannot be schedulded.
 	bool UserProcessHelper::CanBeScheduled(const UserProcess& process)
 	{
-		kcout << "Checking Status...\r";
+		kcout << "Checking process status...\r";
 
 		if (process.Status == ProcessStatusKind::kFrozen ||
 			process.Status == ProcessStatusKind::kDead)
 			return No;
 
-		kcout << "Checking PTime...\r";
+		if (!process.Image &&
+			process.Kind == UserProcess::kExeKind)
+			return No;
 
-		return process.PTime <= 0;
+		return Yes;
 	}
 
 	/**
@@ -450,11 +447,15 @@ namespace Kernel
 				PID prev_pid					   = UserProcessHelper::TheCurrentPID();
 				UserProcessHelper::TheCurrentPID() = new_pid;
 
-				bool ret = HardwareThreadScheduler::The()[index].Leak()->Switch(image_ptr, stack, frame_ptr);
+				auto prev_ptime										 = HardwareThreadScheduler::The()[index].Leak()->fPTime;
+				HardwareThreadScheduler::The()[index].Leak()->fPTime = UserProcessScheduler::The().CurrentTeam().AsArray()[new_pid].ProcessId;
+				Bool ret											 = HardwareThreadScheduler::The()[index].Leak()->Switch(image_ptr, stack, frame_ptr);
 
 				if (!ret)
 				{
-					UserProcessHelper::TheCurrentPID() = prev_pid;
+					HardwareThreadScheduler::The()[index].Leak()->fPTime = prev_ptime;
+					UserProcessHelper::TheCurrentPID()					 = prev_pid;
+
 					continue;
 				}
 			}