Merged in MHR-31 (pull request #16)

MHR-31: Round robin scheduler.

15 files changed, 266 insertions, 160 deletions

diff --git a/Kernel/HALKit/AMD64/HalACPIFactoryInterface.cxx b/Kernel/HALKit/AMD64/HalACPIFactoryInterface.cxx
index 057ba61b..c9b1cb1f 100644
--- a/Kernel/HALKit/AMD64/HalACPIFactoryInterface.cxx
+++ b/Kernel/HALKit/AMD64/HalACPIFactoryInterface.cxx
@@ -12,7 +12,6 @@
 
 namespace NewOS
 {
-
 	/// Custom to the virtual machine, you'll need to parse the MADT instead.
 
 	void rt_shutdown_acpi_qemu_20(void)
@@ -32,9 +31,14 @@ namespace NewOS
 
 	/// You have to parse the MADT!
 
-	ACPIFactoryInterface::ACPIFactoryInterface(voidPtr rsdPtr)
+	ACPIFactoryInterface::ACPIFactoryInterface(VoidPtr rsdPtr)
 		: fRsdp(rsdPtr), fEntries(0)
 	{
+#ifdef __DEBUG__
+		kcout << "newoskrnl: ACPI: init interface.\r";
+#else
+
+#endif
 	}
 
 	Void ACPIFactoryInterface::Shutdown()
diff --git a/Kernel/HALKit/AMD64/HalCoreInterruptHandlerAMD64.cpp b/Kernel/HALKit/AMD64/HalCoreInterruptHandlerAMD64.cpp
index 5f64cc20..657ab622 100644
--- a/Kernel/HALKit/AMD64/HalCoreInterruptHandlerAMD64.cpp
+++ b/Kernel/HALKit/AMD64/HalCoreInterruptHandlerAMD64.cpp
@@ -12,90 +12,82 @@
 /// @param rsp
 EXTERN_C void idt_handle_gpf(NewOS::UIntPtr rsp)
 {
-	MUST_PASS(NewOS::ProcessScheduler::The().Leak().GetCurrent());
-
-	NewOS::kcout << "newoskrnl: Stack Pointer: "
-				 << NewOS::StringBuilder::FromInt("rsp{%}", rsp);
-
 	NewOS::kcout
 		<< "newoskrnl: General Protection Fault, caused by "
-		<< NewOS::ProcessScheduler::The().Leak().GetCurrent().Leak().GetName();
+		<< NewOS::ProcessScheduler::The().Leak().TheCurrent().Leak().GetName();
 
-	NewOS::ProcessScheduler::The().Leak().GetCurrent().Leak().Crash();
-}
-
-/// @brief Handle the scheduler interrupt, raised from the HPET timer.
-/// @param rsp
-EXTERN_C void idt_handle_scheduler(NewOS::UIntPtr rsp)
-{
-	NewOS::kcout << NewOS::StringBuilder::FromInt("rsp{%}", rsp);
-
-	NewOS::kcout
-		<< "newoskrnl: Will be scheduled back later "
-		<< NewOS::ProcessScheduler::The().Leak().GetCurrent().Leak().GetName()
-		<< NewOS::end_line();
-
-	/// schedule another process.
-	if (!NewOS::ProcessHelper::StartScheduling())
-	{
-		NewOS::kcout << "newoskrnl: Continue schedule this process...\r";
-	}
+	NewOS::ProcessScheduler::The().Leak().TheCurrent().Leak().Crash();
 }
 
 /// @brief Handle page fault.
 /// @param rsp
 EXTERN_C void idt_handle_pf(NewOS::UIntPtr rsp)
 {
-	MUST_PASS(NewOS::ProcessScheduler::The().Leak().GetCurrent());
-	NewOS::kcout << NewOS::StringBuilder::FromInt("rsp{%}", rsp);
-
 	NewOS::kcout
 		<< "newoskrnl: Segmentation Fault, caused by "
-		<< NewOS::ProcessScheduler::The().Leak().GetCurrent().Leak().GetName();
+		<< NewOS::ProcessScheduler::The().Leak().TheCurrent().Leak().GetName();
 
-	NewOS::ProcessScheduler::The().Leak().GetCurrent().Leak().Crash();
+	NewOS::ProcessScheduler::The().Leak().TheCurrent().Leak().Crash();
 }
 
 /// @brief Handle math fault.
 /// @param rsp
 EXTERN_C void idt_handle_math(NewOS::UIntPtr rsp)
 {
-	MUST_PASS(NewOS::ProcessScheduler::The().Leak().GetCurrent());
-	NewOS::kcout << NewOS::StringBuilder::FromInt("rsp{%}", rsp);
-
 	NewOS::kcout
 		<< "newoskrnl: Math error, caused by "
-		<< NewOS::ProcessScheduler::The().Leak().GetCurrent().Leak().GetName();
+		<< NewOS::ProcessScheduler::The().Leak().TheCurrent().Leak().GetName();
 
-	NewOS::ProcessScheduler::The().Leak().GetCurrent().Leak().Crash();
+	NewOS::ProcessScheduler::The().Leak().TheCurrent().Leak().Crash();
 }
 
 /// @brief Handle any generic fault.
 /// @param rsp
 EXTERN_C void idt_handle_generic(NewOS::UIntPtr rsp)
 {
-	MUST_PASS(NewOS::ProcessScheduler::The().Leak().GetCurrent());
-	NewOS::kcout << NewOS::StringBuilder::FromInt("sp{%}", rsp);
-
 	NewOS::kcout
 		<< "newoskrnl: Execution error, caused by "
-		<< NewOS::ProcessScheduler::The().Leak().GetCurrent().Leak().GetName();
+		<< NewOS::ProcessScheduler::The().Leak().TheCurrent().Leak().GetName();
 
-	NewOS::ProcessScheduler::The().Leak().GetCurrent().Leak().Crash();
+	NewOS::ProcessScheduler::The().Leak().TheCurrent().Leak().Crash();
 }
 
 /// @brief Handle #UD fault.
 /// @param rsp
 EXTERN_C void idt_handle_ud(NewOS::UIntPtr rsp)
 {
-	MUST_PASS(NewOS::ProcessScheduler::The().Leak().GetCurrent());
-
-	NewOS::kcout << "newoskrnl: Stack Pointer: "
-				 << NewOS::StringBuilder::FromInt("rsp{%}", rsp);
-
 	NewOS::kcout
 		<< "newoskrnl: Invalid interrupt, caused by "
-		<< NewOS::ProcessScheduler::The().Leak().GetCurrent().Leak().GetName();
+		<< NewOS::ProcessScheduler::The().Leak().TheCurrent().Leak().GetName();
+
+	NewOS::ProcessScheduler::The().Leak().TheCurrent().Leak().Crash();
+}
+
+/// @brief Enter syscall from assembly.
+/// @param stack the stack pushed from assembly routine.
+/// @return nothing.
+EXTERN_C NewOS::Void hal_system_call_enter(NewOS::UIntPtr rcx, NewOS::UIntPtr rdx)
+{
+	if (rcx <= (kSyscalls.Count() - 1))
+	{
+		NewOS::kcout << "newoskrnl: syscall: enter.\r";
+
+		if (kSyscalls[rcx].Leak().Leak()->fHooked)
+			(kSyscalls[rcx].Leak().Leak()->fProc)((NewOS::VoidPtr)rdx);
 
-	NewOS::ProcessScheduler::The().Leak().GetCurrent().Leak().Crash();
+		NewOS::kcout << "newoskrnl: syscall: exit.\r";
+	}
+}
+
+/// @brief Enter kernel call from assembly (DDK only).
+/// @param stack the stack pushed from assembly routine.
+/// @return nothing.
+EXTERN_C NewOS::Void hal_kernel_call_enter(NewOS::UIntPtr rcx, NewOS::UIntPtr rdx, NewOS::UIntPtr r8, NewOS::UIntPtr r9)
+{
+	if (rcx != 0)
+	{
+		NewOS::kcout << "newoskrnl: kerncall: enter.\r";
+
+		NewOS::kcout << "newoskrnl: kerncall: exit.\r";
+	}
 }
diff --git a/Kernel/HALKit/AMD64/HalCoreMultiProcessingAMD64.cpp b/Kernel/HALKit/AMD64/HalCoreMultiProcessingAMD64.cpp
index f15faf3c..4e9d2ff6 100644
--- a/Kernel/HALKit/AMD64/HalCoreMultiProcessingAMD64.cpp
+++ b/Kernel/HALKit/AMD64/HalCoreMultiProcessingAMD64.cpp
@@ -10,15 +10,13 @@
 #include <ArchKit/ArchKit.hpp>
 #include <KernelKit/Semaphore.hpp>
 #include <KernelKit/ProcessScheduler.hxx>
+#include <KernelKit/Timer.hpp>
 
 #define kAPIC_ICR_Low	  0x300
 #define kAPIC_ICR_High	  0x310
 #define kAPIC_SIPI_Vector 0x00500
 #define kAPIC_EIPI_Vector 0x00400
 
-/// @brief This symbol is the kernel main symbol.
-EXTERN_C void KeMain();
-
 /// @brief assembly routine. internal use only.
 EXTERN_C void _hal_enable_smp(void);
 
@@ -116,10 +114,16 @@ namespace NewOS::HAL
 
 	///////////////////////////////////////////////////////////////////////////////////////
 
-	STATIC MadtType* kApicInfoBlock			 = nullptr;
-	STATIC UIntPtr	 kApicMadtAddresses[255] = {0};
-	STATIC SizeT	 kApicMadtAddressesCount = 0UL;
-	STATIC UIntPtr	 cBaseAddressAPIC		 = 0xFEE00000;
+	STATIC MadtType* kApicInfoBlock = nullptr;
+
+	STATIC struct
+	{
+		UIntPtr fAddress{0};
+		UInt32	fKind{0};
+	} kApicMadtAddresses[255] = {};
+
+	STATIC SizeT   kApicMadtAddressesCount = 0UL;
+	STATIC UIntPtr cBaseAddressAPIC		   = 0xFEE00000;
 
 	/// @brief this will help us schedule our cores.
 	STATIC Boolean* cProgramInitialized = nullptr;
@@ -159,23 +163,7 @@ namespace NewOS::HAL
 
 	EXTERN_C Void hal_apic_acknowledge_cont(Void)
 	{
-		kcout << "newoskrnl: finish kernel init... \r";
-
-		if (cProgramInitialized &&
-			*cProgramInitialized)
-		{
-			*cProgramInitialized = false;
-
-			kcout << "newoskrnl: putting thread to sleep...\r";
-
-			_hal_spin_core();
-		}
-		else
-		{
-			KeMain();
-
-			_hal_spin_core();
-		}
+		_hal_spin_core();
 	}
 
 	EXTERN_C StackFramePtr _hal_leak_current_context(Void)
@@ -196,16 +184,13 @@ namespace NewOS::HAL
 	STATIC Void hal_switch_context(HAL::StackFramePtr stackFrame)
 	{
 		Semaphore sem;
-		while (sem.IsLocked())
-		{
-		}
 
-		sem.Lock(&ProcessScheduler::The().Leak().GetCurrent().Leak());
+		sem.LockOrWait(&ProcessScheduler::The().Leak().TheCurrent().Leak(), Seconds(5));
 
 		cFramePtr = stackFrame;
 
 		/// yes the exception field contains the core id.
-		hal_send_start_ipi(stackFrame->Exception, 0x40, cBaseAddressAPIC);
+		hal_send_start_ipi(stackFrame->Rcx, 0x40, cBaseAddressAPIC);
 
 		sem.Unlock();
 	}
@@ -219,21 +204,23 @@ namespace NewOS::HAL
 
 		if (kApicMadt != nullptr)
 		{
-			MadtType* madt = (MadtType*)kApicMadt;
+			MadtType* madt = reinterpret_cast<MadtType*>(kApicMadt);
 
 			constexpr auto cMaxProbableCores = 4; // the amount of cores we want.
 			constexpr auto cStartAt			 = 0; // start here to avoid boot core.
 
 			for (SizeT coreAt = cStartAt; coreAt < cMaxProbableCores; ++coreAt)
 			{
-				if (madt->MadtRecords[coreAt].Flags == kThreadLAPIC) // if local apic.
+				if (madt->MadtRecords[coreAt].Flags != kThreadBoot) // if local apic.
 				{
 					MadtType::MadtAddress& madtRecord = madt->MadtRecords[coreAt];
 
 					// then register as a core for scheduler.
-					kcout << "newoskrnl: register core as scheduler thread.\r";
+					kcout << "newoskrnl: Register Local APIC.\r";
+
+					kApicMadtAddresses[kApicMadtAddressesCount].fAddress = madtRecord.Address;
+					kApicMadtAddresses[kApicMadtAddressesCount].fKind	 = madt->MadtRecords[coreAt].Flags;
 
-					kApicMadtAddresses[kApicMadtAddressesCount] = madtRecord.Address;
 					++kApicMadtAddressesCount;
 				}
 			}
@@ -258,7 +245,7 @@ namespace NewOS::HAL
 			cProgramInitialized = new Boolean(true);
 
 			constexpr auto cWhereToInterrupt = 0x40;
-			constexpr auto cWhatCore = 1;
+			constexpr auto cWhatCore		 = 1;
 
 			hal_send_start_ipi(cWhatCore, cWhereToInterrupt, cBaseAddressAPIC);
 		}
diff --git a/Kernel/HALKit/AMD64/HalHardwareMP.cpp b/Kernel/HALKit/AMD64/HalHart.cpp
index 92e075aa..069f3767 100644
--- a/Kernel/HALKit/AMD64/HalHardwareMP.cpp
+++ b/Kernel/HALKit/AMD64/HalHart.cpp
@@ -16,15 +16,19 @@ namespace NewOS
 	{
 		HAL::rt_cli();
 
+		rt_do_context_switch(stack);
+
 		HAL::rt_sti();
 	}
 
-	/// @brief makes thread sleep.
+	/// @brief makes the thread sleep on a loop.
 	/// hooks and hangs thread to prevent code from executing.
 	void rt_hang_thread(HAL::StackFrame* stack)
 	{
-		HAL::rt_cli();
-
-		HAL::rt_sti();
+		while (true)
+		{
+			/* nohing, code is spinning */
+		}
+		
 	}
 } // namespace NewOS
diff --git a/Kernel/HALKit/AMD64/HalInstallTIB.asm b/Kernel/HALKit/AMD64/HalInstallTIB.asm
index f53fb14e..9111c835 100644
--- a/Kernel/HALKit/AMD64/HalInstallTIB.asm
+++ b/Kernel/HALKit/AMD64/HalInstallTIB.asm
@@ -11,6 +11,8 @@
 
 [global rt_install_tib]
 
+section .text
+
 ;; changed: rs, fs
 ;; expected: rcx, rdx
 
diff --git a/Kernel/HALKit/AMD64/HalInterruptAPI.asm b/Kernel/HALKit/AMD64/HalInterruptAPI.asm
index ef5a8319..4832ecf3 100644
--- a/Kernel/HALKit/AMD64/HalInterruptAPI.asm
+++ b/Kernel/HALKit/AMD64/HalInterruptAPI.asm
@@ -157,10 +157,10 @@ __NEW_INT_32:
     pop rcx
     pop rax
 
-    mov eax, 0
+    mov rax, 0
 
     ;; tell there local apic that we're done.
-    mov dword [0xFEE00000 + 0xB0], eax ; LAPIC_EOI
+    mov [0xFEE00000 + 0xB0], rax ; LAPIC_EOI
 
     iretq
 
@@ -195,15 +195,45 @@ IntNormal 47
 IntNormal 48
 IntNormal 49
 
+[extern hal_system_call_enter]
+[extern hal_kernel_call_enter]
+
 __NEW_INT_50:
     cli
 
-    ;; todo handle system calls.
+    push rcx
+    push rdx
+    push rax
+
+    call hal_system_call_enter
+
+    pop rax
+    pop rdx
+    pop rcx
+
+    sti
+    iretq
+
+__NEW_INT_51:
+    cli
+
+    push rcx
+    push rdx
+    push r8
+    push r9
+    push rax
+
+    call hal_kernel_call_enter
+
+    pop rax
+    pop r9
+    pop r8
+    pop rdx
+    pop rcx
 
     sti
     iretq
 
-IntNormal 51
 IntNormal 52
 IntNormal 53
 IntNormal 54
@@ -223,13 +253,19 @@ IntNormal 60
 ;; this one is doing a POST for us.
 ;; testing interrupts.
 _ke_power_on_self_test:
-    int 0x32
-    int 0x32
-    int 0x32
+    mov rcx, 0x10
+    mov rdx, _ke_string_post
+
     int 0x32
 
     ret
 
+section .data
+_ke_string_post:
+    db "POST has been successful.", 0
+
+section .text
+
 [global hal_load_gdt]
 
 hal_load_gdt:
diff --git a/Kernel/HALKit/AMD64/HalKernelMain.cxx b/Kernel/HALKit/AMD64/HalKernelMain.cxx
index 708004b3..8c4a05dc 100644
--- a/Kernel/HALKit/AMD64/HalKernelMain.cxx
+++ b/Kernel/HALKit/AMD64/HalKernelMain.cxx
@@ -14,6 +14,10 @@
 #include <KernelKit/ProcessScheduler.hxx>
 #include <KernelKit/UserHeap.hpp>
 #include <NewKit/Json.hpp>
+#include <KernelKit/CodeManager.hpp>
+
+/// @brief This symbol is the kernel main symbol.
+EXTERN_C void KeMain();
 
 EXTERN_C NewOS::VoidPtr kInterruptVectorTable[];
 
@@ -24,9 +28,21 @@ namespace NewOS::HAL
 	extern void hal_system_get_cores(NewOS::voidPtr rsdPtr);
 } // namespace NewOS::HAL
 
+/* GDT constant. */
+STATIC NewOS::HAL::Detail::NewOSGDT cGdt = {
+	{0, 0, 0, 0x00, 0x00, 0}, // null entry
+	{0, 0, 0, 0x9a, 0xaf, 0}, // kernel code
+	{0, 0, 0, 0x92, 0xaf, 0}, // kernel data
+	{0, 0, 0, 0x00, 0x00, 0}, // null entry
+	{0, 0, 0, 0x9a, 0xaf, 0}, // user code
+	{0, 0, 0, 0x92, 0xaf, 0}, // user data
+};
+
 EXTERN_C void hal_init_platform(
 	NewOS::HEL::HandoverInformationHeader* HandoverHeader)
 {
+	/* Setup globals. */
+	
 	kHandoverHeader = HandoverHeader;
 
 	if (kHandoverHeader->f_Magic != kHandoverMagic &&
@@ -35,29 +51,17 @@ EXTERN_C void hal_init_platform(
 		return;
 	}
 
-	/// Setup kernel globals.
 	kKernelVirtualSize	= HandoverHeader->f_VirtualSize;
 	kKernelVirtualStart = reinterpret_cast<NewOS::VoidPtr>(
 		reinterpret_cast<NewOS::UIntPtr>(HandoverHeader->f_VirtualStart) + kVirtualAddressStartOffset);
 
 	kKernelPhysicalStart = HandoverHeader->f_PhysicalStart;
 
-	STATIC NewOS::HAL::Detail::NewOSGDT GDT = {
-		{0, 0, 0, 0x00, 0x00, 0}, // null entry
-		{0, 0, 0, 0x9a, 0xaf, 0}, // kernel code
-		{0, 0, 0, 0x92, 0xaf, 0}, // kernel data
-		{0, 0, 0, 0x00, 0x00, 0}, // null entry
-		{0, 0, 0, 0x9a, 0xaf, 0}, // user code
-		{0, 0, 0, 0x92, 0xaf, 0}, // user data
-	};
-
 	NewOS::HAL::RegisterGDT gdtBase;
 
-	gdtBase.Base  = reinterpret_cast<NewOS::UIntPtr>(&GDT);
+	gdtBase.Base  = reinterpret_cast<NewOS::UIntPtr>(&cGdt);
 	gdtBase.Limit = sizeof(NewOS::HAL::Detail::NewOSGDT) - 1;
 
-	/// Load GDT.
-
 	NewOS::HAL::GDTLoader gdt;
 	gdt.Load(gdtBase);
 
@@ -70,15 +74,70 @@ EXTERN_C void hal_init_platform(
 	NewOS::HAL::IDTLoader idt;
 	idt.Load(idtBase);
 
-	/// START POST
+	/* install basic syscalls. */
 
-	NewOS::HAL::Detail::_ke_power_on_self_test();
+	constexpr auto cSerialWriteInterrupt = 0x10; // 16
+	constexpr auto cTlsInterrupt = 0x11; // 17
+	constexpr auto cTlsInstallInterrupt = 0x12; // 18
+	constexpr auto cNewInterrupt = 0x13; // 19
+	constexpr auto cDeleteInterrupt = 0x14; // 20
 
-	NewOS::HAL::hal_system_get_cores(kHandoverHeader->f_HardwareTables.f_RsdPtr);
+	kSyscalls[cSerialWriteInterrupt].Leak().Leak()->fProc = [](NewOS::VoidPtr rdx) -> void {
+		const char* msg = (const char*)rdx;
+		NewOS::kcout << "newoskrnl: " << msg << "\r";
+	};
 
-	NewOS::kcout << "newoskrnl: We're done here...\r";
+	kSyscalls[cTlsInterrupt].Leak().Leak()->fProc = [](NewOS::VoidPtr rdx)->void {
+		tls_check_syscall_impl(rdx);
+	};
 
-	while (true)
+	struct PACKED HeapAllocInfo final
 	{
-	}
+		NewOS::VoidPtr fThe;
+		NewOS::Size    fTheSz;
+	};
+
+	struct PACKED ProcessBlockInfo final
+	{
+		ThreadInformationBlock* fTIB;
+		ThreadInformationBlock* fPIB;
+	};
+
+	kSyscalls[cNewInterrupt].Leak().Leak()->fProc = [](NewOS::VoidPtr rdx)->void {
+
+		/// get HAC struct.
+		HeapAllocInfo* rdxInf = reinterpret_cast<HeapAllocInfo*>(rdx);
+		
+		/// assign the fThe field with the pointer.
+		rdxInf->fThe = NewOS::ProcessScheduler::The().Leak().TheCurrent().Leak().New(rdxInf->fTheSz);
+	};
+
+	kSyscalls[cDeleteInterrupt].Leak().Leak()->fProc = [](NewOS::VoidPtr rdx)->void {
+		/// get HAC struct.
+		HeapAllocInfo* rdxInf = reinterpret_cast<HeapAllocInfo*>(rdx);
+		
+		/// delete ptr with sz in mind.
+		NewOS::ProcessScheduler::The().Leak().TheCurrent().Leak().Delete(rdxInf->fThe, rdxInf->fTheSz);
+	};
+	
+	kSyscalls[cTlsInstallInterrupt].Leak().Leak()->fProc = [](NewOS::VoidPtr rdx)->void {
+		ProcessBlockInfo* rdxPb = reinterpret_cast<ProcessBlockInfo*>(rdx);
+
+		/// install the process's fTIB and fPIB.
+		rt_install_tib(rdxPb->fTIB, rdxPb->fPIB);
+	};
+
+	kSyscalls[cSerialWriteInterrupt].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;
+
+	NewOS::HAL::Detail::_ke_power_on_self_test();
+
+	/* Call generic kernel entrypoint. */
+
+	KeMain();
+
+	NewOS::ke_stop(RUNTIME_CHECK_BOOTSTRAP);
 }
diff --git a/Kernel/HALKit/AMD64/HalKernelMouse.cxx b/Kernel/HALKit/AMD64/HalKernelMouse.cxx
index 8dbd328a..5d50e4f2 100644
--- a/Kernel/HALKit/AMD64/HalKernelMouse.cxx
+++ b/Kernel/HALKit/AMD64/HalKernelMouse.cxx
@@ -10,7 +10,7 @@
 #include <KernelKit/Framebuffer.hpp>
 #include <NewKit/Defines.hpp>
 
-// forward decl.
+/// @note forward decl.
 EXTERN_C NewOS::Boolean _hal_draw_mouse();
 EXTERN_C NewOS::Void _hal_init_mouse();
 
diff --git a/Kernel/HALKit/AMD64/HalSMPCoreManager.asm b/Kernel/HALKit/AMD64/HalSMPCoreManager.asm
index c4042b50..320120a4 100644
--- a/Kernel/HALKit/AMD64/HalSMPCoreManager.asm
+++ b/Kernel/HALKit/AMD64/HalSMPCoreManager.asm
@@ -22,59 +22,37 @@ section .text
 ;; rcx: Stack Pointer
 ;; rdx: SMP core address.
 rt_do_context_switch:
-    push rax
     push rcx
-    push rdx
-    push rbx
-    push rbp
-    push rsi
-    push rdi
-    push r8
-    push r9
-    push r10
-    push r11
-    push r12
-    push r13
-    push r14
-    push r15
+    push rax
 
-    jmp _hal_switch_context
+    call _hal_switch_context
 
-    pop r15
-    pop r14
-    pop r13
-    pop r12
-    pop r11
-    pop r10
-    pop r9
-    pop r8
-    pop rdi
-    pop rsi
-    pop rbp
-    pop rbx
-    pop rdx
     pop rcx
     pop rax
-
-    mov eax, 0
-
     retfq
 
 ;; gets the current stack frame.
 rt_get_current_context:
-    push rdx
+    push rax
+
     jmp _hal_leak_current_context
-    mov rdx, rax
-    pop rdx
+
+    mov rax, r9
+    pop rax
+
+    mov r9, rax
+
     retfq
 
 ;; @brief enables a smp core to run.
 _hal_enable_smp:
-; Read the APIC base MSR
+   ; Read the APIC base MSR
    mov ecx, 0x1B ; IA32_APIC_BASE MSR
    rdmsr
+
    ; Enable the APIC by setting bit 11 (APIC Global Enable)
    or rdx, 0x800
+   
    ; Set the base address (0xFEE00000)
    mov eax, 0xFEE
    shl rax, 12
diff --git a/Kernel/HALKit/AMD64/PCI/Iterator.cxx b/Kernel/HALKit/AMD64/PCI/Iterator.cxx
index 8675f171..d3167b46 100644
--- a/Kernel/HALKit/AMD64/PCI/Iterator.cxx
+++ b/Kernel/HALKit/AMD64/PCI/Iterator.cxx
@@ -7,8 +7,8 @@
 #include <KernelKit/PCI/Iterator.hpp>
 
 #define PCI_ITERATOR_FIND_AND_UNWRAP(DEV, SZ) \
-	if (DEV.Leak())                           \
-		return DEV.Leak();
+	if (DEV.Leak().Leak())                    \
+		return *DEV.Leak().Leak();
 
 namespace NewOS::PCI
 {
@@ -25,7 +25,7 @@ namespace NewOS::PCI
 
 					if (dev.Class() == (UChar)type)
 					{
-						fDevices[bus].Leak().Leak() = dev;
+						*fDevices[bus].Leak().Leak() = dev;
 					}
 				}
 			}
diff --git a/Kernel/HALKit/ARM64/Hart.hxx b/Kernel/HALKit/ARM64/Hart.hxx
new file mode 100644
index 00000000..1b16a072
--- /dev/null
+++ b/Kernel/HALKit/ARM64/Hart.hxx
@@ -0,0 +1,28 @@
+/* -------------------------------------------

+

+	Copyright Zeta Electronics Corporation

+

+------------------------------------------- */

+

+#pragma once

+

+#include <NewKit/Defines.hpp>

+

+/// @file HALKit\ARM64\Hart.hxx

+/// @brief ARM64 hardware thread concept.

+

+typedef NewOS::Int32 Arm64HartType;

+

+/// @brief Set PC to specific hart.

+/// @param hart the hart

+/// @param epc the pc.

+/// @return 

+EXTERN_C NewOS::Void hal_switch_to_hart(Arm64HartType hart, NewOS::VoidPtr epc);

+

+/// @brief Hart IPI enum

+enum {

+	cHartIpiTurnOn,

+	cHartIpiTurnOff,

+	cHartIpiStop,

+	cHartIpiResume,

+};

diff --git a/Kernel/HALKit/ARM64/MBCI/.keepme b/Kernel/HALKit/ARM64/MBCI/.keepme
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/Kernel/HALKit/ARM64/MBCI/.keepme
diff --git a/Kernel/HALKit/AXP/CoreSyscallHandlerDEC.cpp b/Kernel/HALKit/AXP/CoreSyscallHandlerDEC.cpp
index ea0997ed..f308b0b5 100644
--- a/Kernel/HALKit/AXP/CoreSyscallHandlerDEC.cpp
+++ b/Kernel/HALKit/AXP/CoreSyscallHandlerDEC.cpp
@@ -5,16 +5,20 @@
 ------------------------------------------- */
 
 #include <ArchKit/ArchKit.hpp>
-#include <HALKit/Alpha/Processor.hpp>
+#include <HALKit/AXP/Processor.hpp>
 
-NewOS::Array<void (*)(NewOS::Int32 id, NewOS::HAL::StackFrame*),
-			 kKernelMaxSystemCalls>
-	kSyscalls;
-
-extern "C" void rt_syscall_handle(NewOS::HAL::StackFrame* stack)
+/// @brief Internal call for syscall, to work with C++.
+/// @param stack
+/// @return nothing.
+EXTERN_C void rt_syscall_handle(NewOS::HAL::StackFrame* stack)
 {
-	for (NewOS::SizeT index = 0UL; index < kKernelMaxSystemCalls; ++index)
+	if (stack->Rcx <= (kSyscalls.Count() - 1))
 	{
-		(kSyscalls[index].Leak().Leak())(stack->ID, stack);
+		NewOS::kcout << "newoskrnl: syscall: enter.\r";
+
+		if (kSyscalls[stack->Rcx].Leak().Leak().fHooked)
+			(kSyscalls[stack->Rcx].Leak().Leak().fProc)(stack);
+
+		NewOS::kcout << "newoskrnl: syscall: exit.\r";
 	}
 }
diff --git a/Kernel/HALKit/POWER/Hart.hxx b/Kernel/HALKit/POWER/Hart.hxx
index 4e4a281b..10066048 100644
--- a/Kernel/HALKit/POWER/Hart.hxx
+++ b/Kernel/HALKit/POWER/Hart.hxx
@@ -26,3 +26,9 @@ typedef struct HalHardwareThread
 	NewOS::UInt32  fPageFlags;
 	PPCHartType	   fIdentNumber;
 } HalHardwareThread;
+
+/// @brief Set PC to specific hart.
+/// @param hart the hart
+/// @param epc the pc.
+/// @return 
+EXTERN_C NewOS::Void hal_switch_to_hart(HalHardwareThread* hart, NewOS::VoidPtr epc);
\ No newline at end of file
diff --git a/Kernel/HALKit/RISCV/Hart.hxx b/Kernel/HALKit/RISCV/Hart.hxx
index 17ec84a1..ba56b7c9 100644
--- a/Kernel/HALKit/RISCV/Hart.hxx
+++ b/Kernel/HALKit/RISCV/Hart.hxx
@@ -16,3 +16,9 @@
 #include <NewKit/Defines.hpp>
 
 typedef NewOS::Int32 Rv64HartType;
+
+/// @brief Set PC to specific hart.
+/// @param hart the hart
+/// @param epc the pc.
+/// @return 
+EXTERN_C NewOS::Void hal_switch_to_hart(Rv64HartType hart, NewOS::VoidPtr epc);
\ No newline at end of file