[IMP] Updated the ARM64 release of ZKA.

[IMP] Shall use the timer on AMD64 by default, a SMP driver will be written if needed.

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

18 files changed, 212 insertions, 174 deletions

diff --git a/dev/ZKA/HALKit/AMD64/HalCoreInterruptHandlerAMD64.cxx b/dev/ZKA/HALKit/AMD64/HalCoreInterruptHandlerAMD64.cxx
index 88b5db36..df2df3b0 100644
--- a/dev/ZKA/HALKit/AMD64/HalCoreInterruptHandlerAMD64.cxx
+++ b/dev/ZKA/HALKit/AMD64/HalCoreInterruptHandlerAMD64.cxx
@@ -52,8 +52,8 @@ EXTERN_C Kernel::Void hal_system_call_enter(Kernel::UIntPtr rcx, Kernel::UIntPtr
 	{
 		Kernel::kcout << "newoskrnl: syscall: enter.\r";
 
-		if (kSyscalls[rcx].Leak().Leak()->fHooked)
-			(kSyscalls[rcx].Leak().Leak()->fProc)((Kernel::VoidPtr)rdx);
+		if (kSyscalls[rcx].fHooked)
+			(kSyscalls[rcx].fProc)((Kernel::VoidPtr)rdx);
 
 		Kernel::kcout << "newoskrnl: syscall: exit.\r";
 	}
@@ -68,8 +68,8 @@ EXTERN_C Kernel::Void hal_kernel_call_enter(Kernel::UIntPtr rcx, Kernel::UIntPtr
 	{
 		Kernel::kcout << "newoskrnl: kerncall: enter.\r";
 
-		if (kKerncalls[rcx].Leak().Leak()->fHooked)
-			(kKerncalls[rcx].Leak().Leak()->fProc)((Kernel::VoidPtr)rdx);
+		if (kKerncalls[rcx].fHooked)
+			(kKerncalls[rcx].fProc)((Kernel::VoidPtr)rdx);
 
 		Kernel::kcout << "newoskrnl: kerncall: exit.\r";
 	}
diff --git a/dev/ZKA/HALKit/AMD64/HalCoreMultiProcessingAMD64.cxx b/dev/ZKA/HALKit/AMD64/HalCoreMultiProcessingAMD64.cxx
index 512ee483..ca38229d 100644
--- a/dev/ZKA/HALKit/AMD64/HalCoreMultiProcessingAMD64.cxx
+++ b/dev/ZKA/HALKit/AMD64/HalCoreMultiProcessingAMD64.cxx
@@ -11,11 +11,10 @@
 #include <KernelKit/Semaphore.hxx>
 #include <KernelKit/ProcessScheduler.hxx>
 #include <KernelKit/Timer.hxx>
-
 #include <Modules/CoreCG/TextRenderer.hxx>
 
 // Needed for SMP. //
-
+#include <FirmwareKit/EFI.hxx>
 #include <KernelKit/MP.hxx>
 
 #define kApicSignature "APIC"
@@ -45,14 +44,12 @@ namespace Kernel::HAL
 
 	EXTERN_C Void _hal_spin_core(Void);
 
-	STATIC Void hal_switch_context(HAL::StackFramePtr stack_frame);
-
 	STATIC struct MADT_TABLE* kMADTBlock = nullptr;
 	STATIC Bool		   kSMPAware  = false;
 	STATIC Int64	   kSMPCount  = 0;
 
 	STATIC Int32   cSMPInterrupt	  = 0;
-	STATIC Int64   cSMPCores[cSMPMax] = {0};
+	STATIC UInt64   cSMPCores[cSMPMax] = {0};
 	STATIC VoidPtr kRawMADT			  = nullptr;
 
 	/// @brief Multiple APIC Descriptor Table.
@@ -136,17 +133,14 @@ namespace Kernel::HAL
 		Kernel::ke_dma_write(targetAddress, kAPIC_ICR_Low, kAPIC_EIPI_Vector | vector);
 	}
 
-	/// @internal
-	EXTERN_C Void hal_ap_startup(Void)
-	{
-	   CGDrawString("100", 10, 50, RGB(0x00, 0x00, 0x00));
-		ke_stop(RUNTIME_CHECK_BOOTSTRAP);
-	}
+	EXTERN_C Void hal_switch_context(HAL::StackFramePtr stack_frame);
 
+	/// @brief Called when the AP is ready.
 	/// @internal
-	EXTERN_C Void _hal_switch_context(HAL::StackFramePtr stack_frame)
+	EXTERN_C Void hal_on_ap_startup(HAL::StackFramePtr stack_frame)
 	{
 		hal_switch_context(stack_frame);
+		ke_stop(RUNTIME_CHECK_FAILED);
 	}
 
 	constexpr auto cMaxPCBBlocks = cMaxHWThreads;
@@ -162,7 +156,7 @@ namespace Kernel::HAL
 		return fBlocks[ProcessScheduler::The().Leak().TheCurrent().Leak().ProcessId % cMaxPCBBlocks].f_Frame;
 	}
 
-	STATIC Void hal_switch_context(HAL::StackFramePtr stack_frame)
+	EXTERN_C Void hal_switch_context(HAL::StackFramePtr stack_frame)
 	{
 		Semaphore semaphore_process;
 
@@ -174,7 +168,10 @@ namespace Kernel::HAL
 		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;
 
+		mp_do_context_switch(stack_frame);
+
 		semaphore_process.Unlock();
+		ke_stop(RUNTIME_CHECK_FAILED);
 	}
 
 	/***********************************************************************************/
@@ -207,19 +204,13 @@ namespace Kernel::HAL
 
 			while (Yes)
 			{
-				if (kMADTBlock->List[index].Type == 0 ||
-					index > cSMPMax)
+				if (kMADTBlock->List[index].Type > 9 ||
+					kSMPCount > cSMPMax)
 					break;
 
 				switch (kMADTBlock->List[index].Type)
 				{
-				case 0x01: {
-					cSMPCores[index] = kMADTBlock->List[index].IOAPIC.IoID;
-					kcout << "newoskrnl: Core ID: " << number(cSMPCores[index]) << endl;
-					++kSMPCount;
-					break;
-				}
-				case 0x02: {
+				case 0x00: {
 					cSMPCores[index] = kMADTBlock->List[index].LAPIC.ProcessorID;
 					kcout << "newoskrnl: Core ID: " << number(cSMPCores[index]) << endl;
 					++kSMPCount;
@@ -236,16 +227,15 @@ namespace Kernel::HAL
 			}
 
 			kcout << "newoskrnl: # of cores: " << number(kSMPCount) << endl;
-			kcout << "newoskrnl: First core ID: " << number(cSMPCores[0]) << endl;
 
 			// Kernel is now SMP aware.
 			// That means that the scheduler is now available (on MP kernels)
 
 			kSMPAware = true;
 
-			// This is used to start the
-			hal_send_end_ipi(cSMPCores[0], 0x34, madt_address);
-			hal_send_start_ipi(cSMPCores[0], 0x34, madt_address);
+			const auto cStartIPI = 0x34;
+
+			/// TODO: Notify AP core that it must start.
 		}
 	}
 } // namespace Kernel::HAL
diff --git a/dev/ZKA/HALKit/AMD64/HalHart.cxx b/dev/ZKA/HALKit/AMD64/HalHart.cxx
index bc0a485e..b438f303 100644
--- a/dev/ZKA/HALKit/AMD64/HalHart.cxx
+++ b/dev/ZKA/HALKit/AMD64/HalHart.cxx
@@ -16,7 +16,7 @@ namespace Kernel
 	{
 		HAL::rt_cli();
 
-		rt_do_context_switch(stack);
+		mp_do_context_switch(stack);
 
 		HAL::rt_sti();
 	}
diff --git a/dev/ZKA/HALKit/AMD64/HalInterruptAPI.asm b/dev/ZKA/HALKit/AMD64/HalInterruptAPI.asm
index 9a637b8a..5ce9cabc 100644
--- a/dev/ZKA/HALKit/AMD64/HalInterruptAPI.asm
+++ b/dev/ZKA/HALKit/AMD64/HalInterruptAPI.asm
@@ -180,13 +180,23 @@ __NEW_INT_51:
     sti
     iretq
 
-[extern hal_ap_startup]
+[extern hal_on_ap_startup]
 
-__NEW_INT_52:
-    cli
+PRESENT        equ 1 << 7
+NOT_SYS        equ 1 << 4
+EXEC           equ 1 << 3
+DC             equ 1 << 2
+RW             equ 1 << 1
+ACCESSED       equ 1 << 0
 
-    jmp hal_ap_startup
+; Flags bits
+GRAN_4K       equ 1 << 7
+SZ_32         equ 1 << 6
+LONG_MODE     equ 1 << 5
 
+__NEW_INT_52:
+    cli
+    jmp hal_on_ap_startup
     sti
     ret
 
diff --git a/dev/ZKA/HALKit/AMD64/HalKernelMain.cxx b/dev/ZKA/HALKit/AMD64/HalKernelMain.cxx
index 6be8eeaf..adfd6894 100644
--- a/dev/ZKA/HALKit/AMD64/HalKernelMain.cxx
+++ b/dev/ZKA/HALKit/AMD64/HalKernelMain.cxx
@@ -141,14 +141,14 @@ Kernel::Void hal_real_init(Kernel::Void) noexcept
 	constexpr auto cLPCOpenMsg			= 0x26;
 	constexpr auto cLPCCloseMsg			= 0x27;
 
-	kSyscalls[cTlsInterrupt].Leak().Leak()->fProc = [](Kernel::VoidPtr rdx) -> void {
+	kSyscalls[cTlsInterrupt].fProc = [](Kernel::VoidPtr rdx) -> void {
 		if (tls_check_syscall_impl(rdx) == false)
 		{
 			Kernel::ProcessScheduler::The().Leak().TheCurrent().Leak().Crash();
 		}
 	};
 
-	kSyscalls[cNewInterrupt].Leak().Leak()->fProc = [](Kernel::VoidPtr rdx) -> void {
+	kSyscalls[cNewInterrupt].fProc = [](Kernel::VoidPtr rdx) -> void {
 		// get HAC struct.
 		HEAP_ALLOC_INFO* rdxInf = reinterpret_cast<HEAP_ALLOC_INFO*>(rdx);
 
@@ -159,7 +159,7 @@ Kernel::Void hal_real_init(Kernel::Void) noexcept
 		rdxInf->fThe = Kernel::ProcessScheduler::The().Leak().TheCurrent().Leak().New(rdxInf->fTheSz);
 	};
 
-	kSyscalls[cDeleteInterrupt].Leak().Leak()->fProc = [](Kernel::VoidPtr rdx) -> void {
+	kSyscalls[cDeleteInterrupt].fProc = [](Kernel::VoidPtr rdx) -> void {
 		// get HAC struct.
 		HEAP_ALLOC_INFO* rdxInf = reinterpret_cast<HEAP_ALLOC_INFO*>(rdx);
 
@@ -170,7 +170,7 @@ Kernel::Void hal_real_init(Kernel::Void) noexcept
 		Kernel::ProcessScheduler::The().Leak().TheCurrent().Leak().Delete(rdxInf->fThe, rdxInf->fTheSz);
 	};
 
-	kSyscalls[cTlsInstallInterrupt].Leak().Leak()->fProc = [](Kernel::VoidPtr rdx) -> void {
+	kSyscalls[cTlsInstallInterrupt].fProc = [](Kernel::VoidPtr rdx) -> void {
 		PROCESS_BLOCK_INFO* rdxPb = reinterpret_cast<PROCESS_BLOCK_INFO*>(rdx);
 
 		if (!rdxPb)
@@ -180,7 +180,7 @@ Kernel::Void hal_real_init(Kernel::Void) noexcept
 		rt_install_tib(rdxPb->fTIB, rdxPb->fGIB);
 	};
 
-	kSyscalls[cExitInterrupt].Leak().Leak()->fProc = [](Kernel::VoidPtr rdx) -> void {
+	kSyscalls[cExitInterrupt].fProc = [](Kernel::VoidPtr rdx) -> void {
 		PROCESS_EXIT_INFO* rdxEi = reinterpret_cast<PROCESS_EXIT_INFO*>(rdx);
 
 		if (!rdxEi)
@@ -190,7 +190,7 @@ Kernel::Void hal_real_init(Kernel::Void) noexcept
 		Kernel::ProcessScheduler::The().Leak().TheCurrent().Leak().Exit(rdxEi->fCode);
 	};
 
-	kSyscalls[cLastExitInterrupt].Leak().Leak()->fProc = [](Kernel::VoidPtr rdx) -> void {
+	kSyscalls[cLastExitInterrupt].fProc = [](Kernel::VoidPtr rdx) -> void {
 		PROCESS_EXIT_INFO* rdxEi = reinterpret_cast<PROCESS_EXIT_INFO*>(rdx);
 
 		if (!rdxEi)
@@ -199,24 +199,24 @@ Kernel::Void hal_real_init(Kernel::Void) noexcept
 		rdxEi->fCode = Kernel::sched_get_exit_code();
 	};
 
-	kSyscalls[cRebootInterrupt].Leak().Leak()->fProc = [](Kernel::VoidPtr rdx) -> void {
+	kSyscalls[cRebootInterrupt].fProc = [](Kernel::VoidPtr rdx) -> void {
 		Kernel::PowerFactoryInterface pow(kHandoverHeader->f_HardwareTables.f_VendorPtr);
 		pow.Reboot();
 	};
 
-	kSyscalls[cShutdownInterrupt].Leak().Leak()->fProc = [](Kernel::VoidPtr rdx) -> void {
+	kSyscalls[cShutdownInterrupt].fProc = [](Kernel::VoidPtr rdx) -> void {
 		Kernel::PowerFactoryInterface pow(kHandoverHeader->f_HardwareTables.f_VendorPtr);
 		pow.Shutdown();
 	};
 
-	kSyscalls[cTlsInterrupt].Leak().Leak()->fHooked		   = true;
-	kSyscalls[cTlsInstallInterrupt].Leak().Leak()->fHooked = true;
-	kSyscalls[cDeleteInterrupt].Leak().Leak()->fHooked	   = true;
-	kSyscalls[cNewInterrupt].Leak().Leak()->fHooked		   = true;
-	kSyscalls[cExitInterrupt].Leak().Leak()->fHooked	   = true;
-	kSyscalls[cLastExitInterrupt].Leak().Leak()->fHooked   = true;
-	kSyscalls[cShutdownInterrupt].Leak().Leak()->fHooked   = true;
-	kSyscalls[cRebootInterrupt].Leak().Leak()->fHooked	   = true;
+	kSyscalls[cTlsInterrupt].fHooked		   = true;
+	kSyscalls[cTlsInstallInterrupt].fHooked = true;
+	kSyscalls[cDeleteInterrupt].fHooked	   = true;
+	kSyscalls[cNewInterrupt].fHooked		   = true;
+	kSyscalls[cExitInterrupt].fHooked	   = true;
+	kSyscalls[cLastExitInterrupt].fHooked   = true;
+	kSyscalls[cShutdownInterrupt].fHooked   = true;
+	kSyscalls[cRebootInterrupt].fHooked	   = true;
 
 	if (kHandoverHeader->f_MultiProcessingEnabled)
 		Kernel::HAL::hal_system_get_cores(kHandoverHeader->f_HardwareTables.f_VendorPtr);
diff --git a/dev/ZKA/HALKit/AMD64/HalMPContextSwitch.asm b/dev/ZKA/HALKit/AMD64/HalMPContextSwitch.asm
index c5af31a0..965d7d07 100644
--- a/dev/ZKA/HALKit/AMD64/HalMPContextSwitch.asm
+++ b/dev/ZKA/HALKit/AMD64/HalMPContextSwitch.asm
@@ -10,7 +10,7 @@
 [bits 64]
 
 [global rt_get_current_context]
-[global rt_do_context_switch]
+[global mp_do_context_switch]
 [global _hal_spin_core]
 [extern _hal_switch_context]
 [extern _hal_leak_current_context]
@@ -20,20 +20,10 @@ section .text
 ;; writes to rdx the stackframe inside rcx.
 ;; rcx: Stack Pointer
 ;; rdx: SMP core address.
-rt_do_context_switch:
-    push rcx
-    call _hal_switch_context
-    pop rcx
-
-    ;; Now grab newly allocated process's stack frame.
-    push rax
-    call _hal_leak_current_context
-    mov r9, rax
-    pop rax
-
+mp_do_context_switch:
     ;; Take care of context switching within AP.
 
-    mov r9, rax
+    mov r9, rcx
 
     mov rbp, [r9 + (8 * 5)]
     mov rsp, [r9 + (8 * 6)]
@@ -60,7 +50,26 @@ rt_do_context_switch:
 
     mov r9, [r9 + (8 * 12)]
 
-    retfq
+    ; User code selector is 0x20 btw (Amlal).
+
+    mov ax, 0x23
+    mov ds, ax
+    mov es, ax
+    mov fs, ax
+    mov gs, ax
+
+    push 0x23
+    push rsp
+
+    pushfq
+    pop rax
+    or rax, 0x200
+    push rax
+
+    push 0x20
+    push rbp
+
+    iretq
 
 ;; gets the current stack frame.
 rt_get_current_context:
diff --git a/dev/ZKA/HALKit/AMD64/HalSchedulerCore.cxx b/dev/ZKA/HALKit/AMD64/HalSchedulerCore.cxx
index 51cbfe4b..072c09be 100644
--- a/dev/ZKA/HALKit/AMD64/HalSchedulerCore.cxx
+++ b/dev/ZKA/HALKit/AMD64/HalSchedulerCore.cxx
@@ -19,7 +19,7 @@ Void PROCESS_HEADER_BLOCK::SetEntrypoint(UIntPtr& imageStart) noexcept
 
 namespace Kernel
 {
-	bool rt_check_stack(HAL::StackFramePtr stackPtr)
+	bool hal_check_stack(HAL::StackFramePtr stackPtr)
 	{
 		if (!stackPtr)
 			return false;
diff --git a/dev/ZKA/HALKit/AMD64/HalTimer.cxx b/dev/ZKA/HALKit/AMD64/HalTimer.cxx
index f88d1143..4bc19801 100644
--- a/dev/ZKA/HALKit/AMD64/HalTimer.cxx
+++ b/dev/ZKA/HALKit/AMD64/HalTimer.cxx
@@ -17,9 +17,10 @@
 

 // timer slot 0

 

-#define cHPETCounterValue (0x0f0 * 0x20)

-#define cHPETConfigValue  (0x010 * 0x20)

-#define cHPETCompValue	  (0x108 * 0x20)

+#define cHPETCounterRegValue (0x00)

+#define cHPETConfigRegValue  (0x20)

+#define cHPETCompRegValue	  (0x24)

+#define cHPETInterruptRegValue	  (0x2C)

 

 ///! BUGS: 0

 ///! @file HalTimer.cxx

@@ -67,19 +68,19 @@ Int32 HardwareTimer::Wait() noexcept
 		return -1;

 

 	// if not enabled yet.

-	if (!(*(fDigitalTimer + cHPETConfigValue) & (1 << 0)))

+	if (!(*(fDigitalTimer + cHPETConfigRegValue) & (1 << 0)))

 	{

-		*(fDigitalTimer + cHPETConfigValue) |= (1 << 0); // enable it

-		*(fDigitalTimer + cHPETConfigValue) |= (1 << 3); // one shot conf

+		*(fDigitalTimer + cHPETConfigRegValue) |= (1 << 0); // enable it

+		*(fDigitalTimer + cHPETConfigRegValue) |= (1 << 3); // one shot conf

 	}

 

 	UInt64 ticks = fWaitFor / ((*(fDigitalTimer) >> 32) & __UINT32_MAX__);

 

-	auto prev = *(fDigitalTimer + cHPETCounterValue);

+	auto prev = *(fDigitalTimer + cHPETCounterRegValue);

 

-	*(fDigitalTimer + cHPETCompValue) = prev + ticks;

+	prev += ticks;

 

-	while (*(fDigitalTimer + cHPETCounterValue) < (ticks));

+	while (*(fDigitalTimer + cHPETCounterRegValue) < (ticks));

 

 	return 0;

 }

diff --git a/dev/ZKA/HALKit/AMD64/HalUtils.asm b/dev/ZKA/HALKit/AMD64/HalUtils.asm
index 1793db8f..0e4caf2b 100644
--- a/dev/ZKA/HALKit/AMD64/HalUtils.asm
+++ b/dev/ZKA/HALKit/AMD64/HalUtils.asm
@@ -25,9 +25,9 @@ rt_install_tib:
 
 [extern cBspDone]
 [extern kApicMadtAddressesCount]
-[extern hal_ap_startup]
+[extern hal_on_ap_startup]
 [global hal_ap_trampoline]
 
 hal_ap_trampoline:
 hal_ap_trampoline_1:
-    jmp    hal_ap_startup
+    jmp    hal_on_ap_startup
diff --git a/dev/ZKA/HALKit/AMD64/PCI/Iterator.cxx b/dev/ZKA/HALKit/AMD64/PCI/Iterator.cxx
index 20a94115..ea38e717 100644
--- a/dev/ZKA/HALKit/AMD64/PCI/Iterator.cxx
+++ b/dev/ZKA/HALKit/AMD64/PCI/Iterator.cxx
@@ -6,10 +6,6 @@
 
 #include <KernelKit/PCI/Iterator.hxx>
 
-#define PCI_ITERATOR_FIND_AND_UNWRAP(DEV, SZ) \
-	if (DEV.Leak().Leak())                    \
-		return *DEV.Leak().Leak();
-
 namespace Kernel::PCI
 {
 	Iterator::Iterator(const Types::PciDeviceKind& type)
@@ -25,7 +21,7 @@ namespace Kernel::PCI
 
 					if (dev.Class() == (UChar)type)
 					{
-						*fDevices[bus].Leak().Leak() = dev;
+						fDevices[bus] = dev;
 					}
 				}
 			}
@@ -36,9 +32,8 @@ namespace Kernel::PCI
 	{
 	}
 
-	Ref<PCI::Device> Iterator::operator[](const Size& sz)
+	Ref<PCI::Device> Iterator::operator[](const Size& at)
 	{
-		PCI_ITERATOR_FIND_AND_UNWRAP(fDevices[sz], sz);
-		return {};
+		return fDevices[at];
 	}
 } // namespace Kernel::PCI
diff --git a/dev/ZKA/HALKit/AMD64/Processor.hxx b/dev/ZKA/HALKit/AMD64/Processor.hxx
index 93540c34..2a42a105 100644
--- a/dev/ZKA/HALKit/AMD64/Processor.hxx
+++ b/dev/ZKA/HALKit/AMD64/Processor.hxx
@@ -262,22 +262,22 @@ namespace Kernel::HAL
 
 		struct PACKED NewOSGDTRecord final
 		{
-			UInt16 Limit0;
-			UInt16 Base0;
-			UInt8  Base1;
-			UInt8  AccessByte;
-			UInt8  Limit1_Flags;
-			UInt8  Base2;
+			UInt16 fLimit0;
+			UInt16 fBase0;
+			UInt8  fBase1;
+			UInt8  fAccessByte;
+			UInt8  fLimit1_Flags;
+			UInt8  fBase2;
 		};
 
 		struct PACKED ALIGN(0x1000) NewOSGDT final
 		{
-			NewOSGDTRecord Null;
-			NewOSGDTRecord KernCode;
-			NewOSGDTRecord KernData;
-			NewOSGDTRecord UserNull;
-			NewOSGDTRecord UserCode;
-			NewOSGDTRecord UserData;
+			NewOSGDTRecord fNull;
+			NewOSGDTRecord fKernCode;
+			NewOSGDTRecord fKernData;
+			NewOSGDTRecord fUserNull;
+			NewOSGDTRecord fUserCode;
+			NewOSGDTRecord fUserData;
 		};
 	} // namespace Detail
 
diff --git a/dev/ZKA/HALKit/ARM64/HalHart.cxx b/dev/ZKA/HALKit/ARM64/HalHart.cxx
index d2a91bf3..68672595 100644
--- a/dev/ZKA/HALKit/ARM64/HalHart.cxx
+++ b/dev/ZKA/HALKit/ARM64/HalHart.cxx
@@ -14,7 +14,7 @@ namespace Kernel
 	/// wakes up thread from hang.
 	void mp_wakeup_thread(HAL::StackFrame* stack)
 	{
-		rt_do_context_switch(stack);
+		mp_do_context_switch(stack);
 	}
 
 	/// @brief makes the thread sleep on a loop.
diff --git a/dev/ZKA/HALKit/ARM64/HalKernelMain.cxx b/dev/ZKA/HALKit/ARM64/HalKernelMain.cxx
index 129170f7..c2886b31 100644
--- a/dev/ZKA/HALKit/ARM64/HalKernelMain.cxx
+++ b/dev/ZKA/HALKit/ARM64/HalKernelMain.cxx
@@ -18,22 +18,27 @@
 #include <KernelKit/CodeManager.hxx>
 #include <Modules/ACPI/ACPIFactoryInterface.hxx>
 #include <NetworkKit/IPC.hxx>
+#include <CFKit/Property.hxx>
+#include <Modules/CoreCG/TextRenderer.hxx>
 
-EXTERN_C Kernel::VoidPtr kInterruptVectorTable[];
+Kernel::Property cKernelVersion;
+Kernel::User cUserSuper{Kernel::RingKind::kRingSuperUser, kSuperUser};
 
-struct PACKED HeapAllocInfo final
+EXTERN Kernel::Boolean kAllocationInProgress;
+
+struct HEAP_ALLOC_INFO final
 {
 	Kernel::VoidPtr fThe;
 	Kernel::Size	fTheSz;
 };
 
-struct PACKED ProcessBlockInfo final
+struct PROCESS_BLOCK_INFO final
 {
 	THREAD_INFORMATION_BLOCK* fTIB;
-	THREAD_INFORMATION_BLOCK* fPIB;
+	THREAD_INFORMATION_BLOCK* fGIB;
 };
 
-struct PACKED ProcessExitInfo final
+struct PROCESS_EXIT_INFO final
 {
 	STATIC constexpr auto cReasonLen = 512;
 
@@ -41,6 +46,16 @@ struct PACKED ProcessExitInfo final
 	Kernel::Char  fReason[cReasonLen];
 };
 
+namespace Kernel::HAL
+{
+	/// @brief Gets the system cores using the MADT.
+	/// @param rsdPtr The 'RSD PTR' data structure.
+	EXTERN void hal_system_get_cores(Kernel::voidPtr rsdPtr);
+} // namespace Kernel::HAL
+
+Kernel::Void hal_real_init(Kernel::Void) noexcept;
+EXTERN_C Kernel::Void ke_dll_entrypoint(Kernel::Void);
+
 EXTERN_C void hal_init_platform(
 	Kernel::HEL::HandoverInformationHeader* HandoverHeader)
 {
@@ -54,38 +69,46 @@ EXTERN_C void hal_init_platform(
 		return;
 	}
 
-	kKernelVirtualSize	= HandoverHeader->f_VirtualSize;
+	hal_real_init();
+}
+
+Kernel::Void hal_real_init(Kernel::Void) noexcept
+{
+	// reset kAllocationInProgress field to zero.
+	kAllocationInProgress = false;
+
+	kKernelVMHStart = kHandoverHeader->f_HeapStart;
+
+	// get page size.
+	kKernelVirtualSize = kHandoverHeader->f_VirtualSize;
+
+	// get virtual address start (for the heap)
 	kKernelVirtualStart = reinterpret_cast<Kernel::VoidPtr>(
-		reinterpret_cast<Kernel::UIntPtr>(HandoverHeader->f_VirtualStart) + cHeapStartOffset);
-
-	kKernelPhysicalStart = HandoverHeader->f_PhysicalStart;
-
-	// Register the basic SCI functions.
-
-	constexpr auto cSerialAlertInterrupt = 0x10;
-	constexpr auto cTlsInterrupt		 = 0x11;
-	constexpr auto cTlsInstallInterrupt	 = 0x12;
-	constexpr auto cNewInterrupt		 = 0x13;
-	constexpr auto cDeleteInterrupt		 = 0x14;
-	constexpr auto cExitInterrupt		 = 0x15;
-	constexpr auto cLastExitInterrupt	 = 0x16;
-	constexpr auto cCatalogOpen			 = 0x17;
-	constexpr auto cForkRead			 = 0x18;
-	constexpr auto cForkWrite			 = 0x19;
-	constexpr auto cCatalogClose		 = 0x20;
-	constexpr auto cCatalogRemove		 = 0x21;
-	constexpr auto cCatalogCreate		 = 0x22;
-	constexpr auto cRebootInterrupt		 = 0x23;
-	constexpr auto cShutdownInterrupt	 = 0x24;
-	constexpr auto cLPCSendMsg			 = 0x25;
-	constexpr auto cLPCOpenMsg			 = 0x26;
-	constexpr auto cLPCCloseMsg			 = 0x27;
-	constexpr auto cLPCSanitizeMsg		 = 0x28;
-
-	kSyscalls[cSerialAlertInterrupt].Leak().Leak()->fProc = [](Kernel::VoidPtr rdx) -> void {
-		const Kernel::Char* msg = (const Kernel::Char*)rdx;
-		Kernel::kcout << "Kernel: " << msg << "\r";
-	};
+		reinterpret_cast<Kernel::UIntPtr>(kHandoverHeader->f_VirtualStart));
+
+	// get physical address start.
+	kKernelPhysicalStart = reinterpret_cast<Kernel::VoidPtr>(
+		reinterpret_cast<Kernel::UIntPtr>(kHandoverHeader->f_PhysicalStart));
+
+	// Register the basic system calls.
+
+	constexpr auto cTlsInterrupt		= 0x11;
+	constexpr auto cTlsInstallInterrupt = 0x12;
+	constexpr auto cNewInterrupt		= 0x13;
+	constexpr auto cDeleteInterrupt		= 0x14;
+	constexpr auto cExitInterrupt		= 0x15;
+	constexpr auto cLastExitInterrupt	= 0x16;
+	constexpr auto cCatalogOpen			= 0x17;
+	constexpr auto cForkRead			= 0x18;
+	constexpr auto cForkWrite			= 0x19;
+	constexpr auto cCatalogClose		= 0x20;
+	constexpr auto cCatalogRemove		= 0x21;
+	constexpr auto cCatalogCreate		= 0x22;
+	constexpr auto cRebootInterrupt		= 0x23;
+	constexpr auto cShutdownInterrupt	= 0x24;
+	constexpr auto cLPCSendMsg			= 0x25;
+	constexpr auto cLPCOpenMsg			= 0x26;
+	constexpr auto cLPCCloseMsg			= 0x27;
 
 	kSyscalls[cTlsInterrupt].Leak().Leak()->fProc = [](Kernel::VoidPtr rdx) -> void {
 		if (tls_check_syscall_impl(rdx) == false)
@@ -94,13 +117,9 @@ EXTERN_C void hal_init_platform(
 		}
 	};
 
-	kSyscalls[cLPCSanitizeMsg].Leak().Leak()->fProc = [](Kernel::VoidPtr rdx) -> void {
-		Kernel::ipc_sanitize_packet(reinterpret_cast<Kernel::IPC_MESSAGE_STRUCT*>(rdx));
-	};
-
 	kSyscalls[cNewInterrupt].Leak().Leak()->fProc = [](Kernel::VoidPtr rdx) -> void {
 		// get HAC struct.
-		HeapAllocInfo* rdxInf = reinterpret_cast<HeapAllocInfo*>(rdx);
+		HEAP_ALLOC_INFO* rdxInf = reinterpret_cast<HEAP_ALLOC_INFO*>(rdx);
 
 		if (!rdxInf)
 			return;
@@ -111,7 +130,7 @@ EXTERN_C void hal_init_platform(
 
 	kSyscalls[cDeleteInterrupt].Leak().Leak()->fProc = [](Kernel::VoidPtr rdx) -> void {
 		// get HAC struct.
-		HeapAllocInfo* rdxInf = reinterpret_cast<HeapAllocInfo*>(rdx);
+		HEAP_ALLOC_INFO* rdxInf = reinterpret_cast<HEAP_ALLOC_INFO*>(rdx);
 
 		if (!rdxInf)
 			return;
@@ -121,17 +140,17 @@ EXTERN_C void hal_init_platform(
 	};
 
 	kSyscalls[cTlsInstallInterrupt].Leak().Leak()->fProc = [](Kernel::VoidPtr rdx) -> void {
-		ProcessBlockInfo* rdxPb = reinterpret_cast<ProcessBlockInfo*>(rdx);
+		PROCESS_BLOCK_INFO* rdxPb = reinterpret_cast<PROCESS_BLOCK_INFO*>(rdx);
 
 		if (!rdxPb)
 			return;
 
-		// install the fTIB and fPIB.
-		rt_install_tib(rdxPb->fTIB, rdxPb->fPIB);
+		// install the fTIB and fGIB.
+		rt_install_tib(rdxPb->fTIB, rdxPb->fGIB);
 	};
 
 	kSyscalls[cExitInterrupt].Leak().Leak()->fProc = [](Kernel::VoidPtr rdx) -> void {
-		ProcessExitInfo* rdxEi = reinterpret_cast<ProcessExitInfo*>(rdx);
+		PROCESS_EXIT_INFO* rdxEi = reinterpret_cast<PROCESS_EXIT_INFO*>(rdx);
 
 		if (!rdxEi)
 			return;
@@ -141,7 +160,7 @@ EXTERN_C void hal_init_platform(
 	};
 
 	kSyscalls[cLastExitInterrupt].Leak().Leak()->fProc = [](Kernel::VoidPtr rdx) -> void {
-		ProcessExitInfo* rdxEi = reinterpret_cast<ProcessExitInfo*>(rdx);
+		PROCESS_EXIT_INFO* rdxEi = reinterpret_cast<PROCESS_EXIT_INFO*>(rdx);
 
 		if (!rdxEi)
 			return;
@@ -150,23 +169,41 @@ EXTERN_C void hal_init_platform(
 	};
 
 	kSyscalls[cRebootInterrupt].Leak().Leak()->fProc = [](Kernel::VoidPtr rdx) -> void {
-		Kernel::ACPIFactoryInterface acpi(kHandoverHeader->f_HardwareTables.f_VendorPtr);
-		acpi.Reboot();
+		Kernel::PowerFactoryInterface pow(kHandoverHeader->f_HardwareTables.f_VendorPtr);
+		pow.Reboot();
 	};
 
 	kSyscalls[cShutdownInterrupt].Leak().Leak()->fProc = [](Kernel::VoidPtr rdx) -> void {
-		Kernel::ACPIFactoryInterface acpi(kHandoverHeader->f_HardwareTables.f_VendorPtr);
-		acpi.Shutdown();
+		Kernel::PowerFactoryInterface pow(kHandoverHeader->f_HardwareTables.f_VendorPtr);
+		pow.Shutdown();
 	};
 
-	kSyscalls[cSerialAlertInterrupt].Leak().Leak()->fHooked = true;
-	kSyscalls[cTlsInterrupt].Leak().Leak()->fHooked			= true;
-	kSyscalls[cTlsInstallInterrupt].Leak().Leak()->fHooked	= true;
-	kSyscalls[cDeleteInterrupt].Leak().Leak()->fHooked		= true;
-	kSyscalls[cNewInterrupt].Leak().Leak()->fHooked			= true;
-	kSyscalls[cExitInterrupt].Leak().Leak()->fHooked		= true;
-	kSyscalls[cLastExitInterrupt].Leak().Leak()->fHooked	= true;
-	kSyscalls[cShutdownInterrupt].Leak().Leak()->fHooked	= true;
-	kSyscalls[cRebootInterrupt].Leak().Leak()->fHooked		= true;
-	kSyscalls[cLPCSanitizeMsg].Leak().Leak()->fHooked		= true;
+	kSyscalls[cTlsInterrupt].Leak().Leak()->fHooked		   = true;
+	kSyscalls[cTlsInstallInterrupt].Leak().Leak()->fHooked = true;
+	kSyscalls[cDeleteInterrupt].Leak().Leak()->fHooked	   = true;
+	kSyscalls[cNewInterrupt].Leak().Leak()->fHooked		   = true;
+	kSyscalls[cExitInterrupt].Leak().Leak()->fHooked	   = true;
+	kSyscalls[cLastExitInterrupt].Leak().Leak()->fHooked   = true;
+	kSyscalls[cShutdownInterrupt].Leak().Leak()->fHooked   = true;
+	kSyscalls[cRebootInterrupt].Leak().Leak()->fHooked	   = true;
+
+	if (kHandoverHeader->f_MultiProcessingEnabled)
+		Kernel::HAL::hal_system_get_cores(kHandoverHeader->f_HardwareTables.f_VendorPtr);
+
+	Kernel::kcout << "newoskrnl: Creating filesystem and such.\r";
+
+	auto fs = new Kernel::NewFilesystemManager();
+
+	MUST_PASS(fs);
+	MUST_PASS(fs->GetParser());
+
+	Kernel::NewFilesystemManager::Mount(fs);
+
+	const auto cPassword = "ZKA_KERNEL_AUTHORITY";
+
+	cUserSuper.TrySave(cPassword);
+
+	ke_dll_entrypoint();
+
+	Kernel::ke_stop(RUNTIME_CHECK_FAILED);
 }
diff --git a/dev/ZKA/HALKit/ARM64/HalScheduler.cxx b/dev/ZKA/HALKit/ARM64/HalScheduler.cxx
index 51cbfe4b..072c09be 100644
--- a/dev/ZKA/HALKit/ARM64/HalScheduler.cxx
+++ b/dev/ZKA/HALKit/ARM64/HalScheduler.cxx
@@ -19,7 +19,7 @@ Void PROCESS_HEADER_BLOCK::SetEntrypoint(UIntPtr& imageStart) noexcept
 
 namespace Kernel
 {
-	bool rt_check_stack(HAL::StackFramePtr stackPtr)
+	bool hal_check_stack(HAL::StackFramePtr stackPtr)
 	{
 		if (!stackPtr)
 			return false;
diff --git a/dev/ZKA/HALKit/ARM64/HalTimer.cxx b/dev/ZKA/HALKit/ARM64/HalTimer.cxx
index ef907e4f..4ef87227 100644
--- a/dev/ZKA/HALKit/ARM64/HalTimer.cxx
+++ b/dev/ZKA/HALKit/ARM64/HalTimer.cxx
@@ -13,4 +13,4 @@
 
 #include <ArchKit/ArchKit.hxx>
 
-struct TimerInfoStruct;
+struct TIMER_INFO;
diff --git a/dev/ZKA/HALKit/ARM64/Processor.hxx b/dev/ZKA/HALKit/ARM64/Processor.hxx
index 16e9ec8c..985dfe64 100644
--- a/dev/ZKA/HALKit/ARM64/Processor.hxx
+++ b/dev/ZKA/HALKit/ARM64/Processor.hxx
@@ -19,12 +19,6 @@
 
 #define kCPUBackendName "ARMv8"
 
-#ifdef __ZETA_MACHINE__
-#define cHeapStartOffset (0x10000000)
-#else
-#error !!! please provide that macro. !!!
-#endif
-
 namespace Kernel::HAL
 {
 	struct PACKED Register64 final
@@ -48,7 +42,9 @@ namespace Kernel::HAL
 	typedef StackFrame* StackFramePtr;
 } // namespace Kernel::HAL
 
-inline Kernel::VoidPtr kKernelVirtualStart = (Kernel::VoidPtr)cHeapStartOffset;
+
+inline Kernel::VoidPtr kKernelVMHStart	   = nullptr;
+inline Kernel::VoidPtr kKernelVirtualStart = nullptr;
 inline Kernel::UIntPtr kKernelVirtualSize  = 0UL;
 
 inline Kernel::VoidPtr kKernelPhysicalStart = nullptr;
diff --git a/dev/ZKA/HALKit/ARM64/Storage/HalFlash.cxx b/dev/ZKA/HALKit/ARM64/Storage/HalFlash.cxx
index cc7802cb..ac17d658 100644
--- a/dev/ZKA/HALKit/ARM64/Storage/HalFlash.cxx
+++ b/dev/ZKA/HALKit/ARM64/Storage/HalFlash.cxx
@@ -10,7 +10,7 @@
 /// @file Flash.cxx
 /// @brief Flash memory builtin.
 
-#ifdef __FLASH_MEM__
+#ifdef __USE_MBCI_FLASH__
 
 #define cMaxFlash (4U)
 
@@ -53,14 +53,14 @@ namespace Kernel
 	/// @brief Enable flash memory at slot.
 	STATIC Void drv_enable_flash(Int32 arg)
 	{
-		kcout << "newoskrnl: enabled hardware.\r";
+		kcout << "newoskrnl: Enabled FLSH hardware.\r";
 	}
 
 	/// @brief Disable flash memory at slot.
 	STATIC Void drv_disable_flash(Int32 arg)
 	{
-		kcout << "newoskrnl: disabled hardware.\r";
+		kcout << "newoskrnl: Disabled FLSH hardware.\r";
 	}
 } // namespace Kernel
 
-#endif // if __FLASH_MEM__ (Bridge)
+#endif // if __USE_MBCI_FLASH__ (Bridge)
diff --git a/dev/ZKA/HALKit/POWER/HalContextSwitchPowerPC.s b/dev/ZKA/HALKit/POWER/HalContextSwitchPowerPC.s
index fc47ba49..9a9c3aa6 100644
--- a/dev/ZKA/HALKit/POWER/HalContextSwitchPowerPC.s
+++ b/dev/ZKA/HALKit/POWER/HalContextSwitchPowerPC.s
@@ -7,10 +7,10 @@
 .align 4
 .type name, @function
 .text
-.globl rt_do_context_switch
+.globl mp_do_context_switch
 
 /* r3 (3) = assigner stack, r4 (4) = assignee stack */
-rt_do_context_switch:
+mp_do_context_switch:
     lwz 0(%4), 0(%3)
     lwz 4(%4), 4(%3)
     lwz 8(%4), 8(%3)