[SMP] WiP impelementation of SMP inside the HAL.

- Doing R&D on SMP on AMD64,
- Working on a first application.

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

15 files changed, 92 insertions, 117 deletions

diff --git a/Kernel/HALKit/AMD64/HalCoreMultiProcessingAMD64.cxx b/Kernel/HALKit/AMD64/HalCoreMultiProcessingAMD64.cxx
index 48d737fe..0557afac 100644
--- a/Kernel/HALKit/AMD64/HalCoreMultiProcessingAMD64.cxx
+++ b/Kernel/HALKit/AMD64/HalCoreMultiProcessingAMD64.cxx
@@ -67,13 +67,13 @@ namespace Kernel::HAL
 	/// @brief Multiple APIC Descriptor Table.
 	struct MadtType final : public SDT
 	{
+		UInt32 Address;
+		UInt32 Flags; // 1 = Dual Legacy PICs installed
+
 		struct MadtAddress final
 		{
 			Char RecordType;
 			Char RecordLen; // record length
-
-			UInt32 Address;
-			UInt32 Flags; // 1 = Dual Legacy PICs installed
 		} MadtRecords[];
 	};
 
@@ -120,13 +120,8 @@ namespace Kernel::HAL
 
 	STATIC MadtType* kApicInfoBlock = nullptr;
 
-	STATIC struct
-	{
-		UIntPtr fAddress{0};
-		UInt32	fKind{0};
-	} kApicMadtAddresses[255] = {};
-
-	STATIC SizeT kApicMadtAddressesCount = 0UL;
+	EXTERN_C SizeT kApicMadtAddressesCount = 0UL;
+	EXTERN_C SizeT cBspDone				   = 0UL;
 
 	enum
 	{
@@ -170,9 +165,12 @@ namespace Kernel::HAL
 	}
 
 	/// @internal
-	EXTERN_C Void hal_apic_acknowledge(Void)
+	EXTERN_C Void hal_ap_startup(Void)
 	{
-		kcout << "newoskrnl: acknowledge APIC.\r";
+		while (Yes)
+		{
+			
+		}
 	}
 
 	/// @internal
@@ -216,6 +214,8 @@ namespace Kernel::HAL
 		return (eax & 0xfffff000) | ((UIntPtr)(edx & 0x0f) << 32);
 	}
 
+	EXTERN_C Void hal_ap_trampoline(Void);
+
 	/// @brief Fetch and enable cores inside main CPU.
 	/// @param rsdPtr RSD PTR structure.
 	Void hal_system_get_cores(voidPtr rsdPtr)
@@ -225,16 +225,15 @@ namespace Kernel::HAL
 
 		if (kApicMadt != nullptr)
 		{
-			MadtType* madt = reinterpret_cast<MadtType*>(kApicMadt);
-
-			cpu_set_apic_base(cpu_get_apic_base());
+			UInt8 bsp_id, bsp_done = No;
 
-			// set SVR register to bit 8 to start recieve interrupts.
+			UInt32	num_cores			= 4;
+			UInt32* local_apic_ptr		= nullptr;
+			UInt32* local_apic_ids[255] = {0};
 
-			auto flagsSet = Kernel::ke_dma_read(cAPICAddress, 0xF0); // SVR register.
-			flagsSet |= 0x100;
+			MadtType* type = (MadtType*)kApicMadt;
 
-			Kernel::ke_dma_write(cAPICAddress, 0xF0, flagsSet | 0x100);
+			local_apic_ptr = (UInt32*)type->Address;
 		}
 		else
 		{
diff --git a/Kernel/HALKit/AMD64/HalInterruptAPI.asm b/Kernel/HALKit/AMD64/HalInterruptAPI.asm
index c09d5a06..b7cddea8 100644
--- a/Kernel/HALKit/AMD64/HalInterruptAPI.asm
+++ b/Kernel/HALKit/AMD64/HalInterruptAPI.asm
@@ -119,16 +119,8 @@ IntExp   30
 
 IntNormal 31
 
-[extern hal_apic_acknowledge]
-
-__NEW_INT_34:
-    push rax
-    call hal_apic_acknowledge
-    pop rax
-
-    iretq
-
 IntNormal 32
+IntNormal 34
 
 IntNormal 33
 IntNormal 35
diff --git a/Kernel/HALKit/AMD64/HalKernelMain.cxx b/Kernel/HALKit/AMD64/HalKernelMain.cxx
index a4067c84..4a6fa302 100644
--- a/Kernel/HALKit/AMD64/HalKernelMain.cxx
+++ b/Kernel/HALKit/AMD64/HalKernelMain.cxx
@@ -216,7 +216,7 @@ EXTERN_C void hal_init_platform(
 	kSyscalls[cRebootInterrupt].Leak().Leak()->fHooked		= true;
 	kSyscalls[cLPCSanitizeMsg].Leak().Leak()->fHooked		= true;
 
-	// newoskrnl version 1.00
+	// newoskrnl version 1.00.
 	Kernel::StringView strVer(cMaxPropLen);
 	strVer += "\\Properties\\KernelVersion";
 
diff --git a/Kernel/HALKit/AMD64/HalRoutines.s b/Kernel/HALKit/AMD64/HalRoutines.s
index e4944111..321ad3d3 100644
--- a/Kernel/HALKit/AMD64/HalRoutines.s
+++ b/Kernel/HALKit/AMD64/HalRoutines.s
@@ -2,6 +2,7 @@
 .globl hal_load_gdt
 .globl rt_wait_400ns
 .globl rt_get_current_context
+.globl hal_ap_trampoline
 
 .section .text
 rt_wait_400ns:
diff --git a/Kernel/HALKit/AMD64/HalUtils.asm b/Kernel/HALKit/AMD64/HalUtils.asm
index 6681a692..86d9983e 100644
--- a/Kernel/HALKit/AMD64/HalUtils.asm
+++ b/Kernel/HALKit/AMD64/HalUtils.asm
@@ -23,27 +23,11 @@ rt_install_tib:
 
 ;; //////////////////////////////////////////////////// ;;
 
-[global rt_jump_user_mode]
-
-;; @used rcx, address to jump on.
-;; @note adjusted for long mode.
-rt_jump_user_mode:
-	cmp rcx, 0
-	je rt_jump_user_mode_failed
-
-	mov ax, (6 * 8) | 3 ; user data segment with RPL 3
-	mov ds, ax
-	mov es, ax
-	mov fs, ax
-	mov gs, ax ; SS is handled by iret
-
-	mov rax, rsp
-	push (6 * 8) | 3
-	push rax
-	pushf
-	push (5 * 8) | 3 ; user code segment with RPL 3
-	push rcx
-	iretq
-	;; we just failed to validate the rcx, fallback and return to previous pc.
-rt_jump_user_mode_failed:
-	ret
\ No newline at end of file
+[extern cBspDone]
+[extern kApicMadtAddressesCount]
+[extern hal_ap_startup]
+[global hal_ap_trampoline]
+
+hal_ap_trampoline:
+hal_ap_trampoline_1:  
+    jmp    hal_ap_startup
diff --git a/Kernel/KernelKit/Defines.hpp b/Kernel/KernelKit/Defines.hpp
index 32f67f10..191d1098 100644
--- a/Kernel/KernelKit/Defines.hpp
+++ b/Kernel/KernelKit/Defines.hpp
@@ -8,5 +8,5 @@
 
 #include <NewKit/Defines.hpp>
 
-#define KERNELKIT_VERSION "1.01"
-#define KERNELKIT_RELEASE "Cairo"
+#define KERNELKIT_VERSION "1.02"
+#define KERNELKIT_RELEASE "Alexandria"
diff --git a/Kernel/KernelKit/Heap.hxx b/Kernel/KernelKit/Heap.hxx
index 0f673ffb..1ed029cd 100644
--- a/Kernel/KernelKit/Heap.hxx
+++ b/Kernel/KernelKit/Heap.hxx
@@ -18,12 +18,12 @@ namespace Kernel
 	/// @brief Declare pointer as free.
 	/// @param allocatedPtr the pointer.
 	/// @return
-	Int32 ke_delete_ke_heap(voidPtr allocatedPtr);
+	Int32 mm_delete_ke_heap(voidPtr allocatedPtr);
 
 	/// @brief Declare a new size for allocatedPtr.
 	/// @param allocatedPtr the pointer.
 	/// @return
-	voidPtr ke_realloc_ke_heap(voidPtr allocatedPtr, SizeT newSz);
+	voidPtr mm_realloc_ke_heap(voidPtr allocatedPtr, SizeT newSz);
 
 	/// @brief Check if pointer is a valid kernel pointer.
 	/// @param allocatedPtr the pointer
@@ -35,17 +35,17 @@ namespace Kernel
 	/// @param rw read write (true to enable it)
 	/// @param user is it accesible by user processes?
 	/// @return the pointer
-	voidPtr ke_new_ke_heap(const SizeT sz, const Bool rw, const Bool user);
+	voidPtr mm_new_ke_heap(const SizeT sz, const Bool rw, const Bool user);
 
 	/// @brief Protect the heap with a CRC value.
 	/// @param allocatedPtr pointer.
 	/// @return if it valid: point has crc now., otherwise fail.
-	Boolean ke_protect_ke_heap(VoidPtr allocatedPtr);
+	Boolean mm_protect_ke_heap(VoidPtr allocatedPtr);
 
 	/// @brief Makes a kernel heap page.
 	/// @param allocatedPtr the page pointer.
 	/// @return
-	Int32 ke_make_ke_page(VoidPtr allocatedPtr);
+	Int32 mm_make_ke_page(VoidPtr allocatedPtr);
 } // namespace Kernel
 
 #endif // !_INC_KERNEL_HEAP_HXX_
diff --git a/Kernel/KernelKit/LoaderInterface.hpp b/Kernel/KernelKit/LoaderInterface.hpp
index a6b54d8b..e49e0085 100644
--- a/Kernel/KernelKit/LoaderInterface.hpp
+++ b/Kernel/KernelKit/LoaderInterface.hpp
@@ -24,7 +24,7 @@ namespace Kernel
 		NEWOS_COPY_DEFAULT(LoaderInterface);
 
 	public:
-		virtual _Output const char* FormatAsString()											= 0;
+		virtual _Output const char* AsString()											= 0;
 		virtual _Output const char* MIME()														= 0;
 		virtual _Output const char* Path()														= 0;
 		virtual _Output ErrorOr<VoidPtr> FindStart()											= 0;
diff --git a/Kernel/KernelKit/MPManager.hpp b/Kernel/KernelKit/MPManager.hpp
index 6f23dd66..ccd1af37 100644
--- a/Kernel/KernelKit/MPManager.hpp
+++ b/Kernel/KernelKit/MPManager.hpp
@@ -66,11 +66,11 @@ namespace Kernel
 
 	private:
 		HAL::StackFrame* fStack{nullptr};
-		ThreadKind		 fKind;
-		ThreadID		 fID;
-		ProcessID		 fSourcePID;
-		bool			 fWakeup;
-		bool			 fBusy;
+		ThreadKind		 fKind{ThreadKind::kInvalidHart};
+		ThreadID		 fID{0};
+		ProcessID		 fSourcePID{-1};
+		bool			 fWakeup{false};
+		bool			 fBusy{false};
 
 	private:
 		friend class MPManager;
diff --git a/Kernel/KernelKit/PEFCodeManager.hxx b/Kernel/KernelKit/PEFCodeManager.hxx
index 5e48331a..7f06e5ad 100644
--- a/Kernel/KernelKit/PEFCodeManager.hxx
+++ b/Kernel/KernelKit/PEFCodeManager.hxx
@@ -35,7 +35,7 @@ namespace Kernel
 
 	public:
 		const char* Path() override;
-		const char* FormatAsString() override;
+		const char* AsString() override;
 		const char* MIME() override;
 
 	public:
diff --git a/Kernel/Sources/Heap.cxx b/Kernel/Sources/Heap.cxx
index b2acaffe..25a77d6b 100644
--- a/Kernel/Sources/Heap.cxx
+++ b/Kernel/Sources/Heap.cxx
@@ -21,12 +21,12 @@ namespace Kernel
 	STATIC SizeT	   kHeapCount = 0UL;
 	STATIC PageManager kHeapPageManager;
 
-	namespace Detail
+	namespace Details
 	{
 		/// @brief Kernel heap information block.
 		/// Located before the address bytes.
 		/// | HIB |  ADDRESS  |
-		struct PACKED HeapInformationBlock final
+		struct PACKED HEAP_INFORMATION_BLOCK final
 		{
 			///! @brief 32-bit value which contains the magic number of the executable.
 			UInt32 fMagic;
@@ -44,26 +44,26 @@ namespace Kernel
 			UInt8 fPadding[kKernelHeapHeaderPaddingSz];
 		};
 
-		typedef HeapInformationBlock* HeapInformationBlockPtr;
+		typedef HEAP_INFORMATION_BLOCK* HEAP_INFORMATION_BLOCK_PTR;
 	} // namespace Detail
 
 	/// @brief Declare a new size for allocatedPtr.
 	/// @param allocatedPtr the pointer.
 	/// @return
-	voidPtr ke_realloc_ke_heap(voidPtr allocatedPtr, SizeT newSz)
+	voidPtr mm_realloc_ke_heap(voidPtr allocatedPtr, SizeT newSz)
 	{
 		if (!allocatedPtr || newSz < 1)
 			return nullptr;
 
-		Detail::HeapInformationBlockPtr heapInfoBlk =
-			reinterpret_cast<Detail::HeapInformationBlockPtr>(
-				(UIntPtr)allocatedPtr - sizeof(Detail::HeapInformationBlock));
+		Details::HEAP_INFORMATION_BLOCK_PTR heapInfoBlk =
+			reinterpret_cast<Details::HEAP_INFORMATION_BLOCK_PTR>(
+				(UIntPtr)allocatedPtr - sizeof(Details::HEAP_INFORMATION_BLOCK));
 
 		heapInfoBlk->fTargetPtrSize = newSz;
 
 		if (heapInfoBlk->fCRC32 > 0)
 		{
-			MUST_PASS(ke_protect_ke_heap(allocatedPtr));
+			MUST_PASS(mm_protect_ke_heap(allocatedPtr));
 		}
 
 		return allocatedPtr;
@@ -74,7 +74,7 @@ namespace Kernel
 	/// @param rw read write (true to enable it)
 	/// @param user is it accesible by user processes?
 	/// @return the pointer
-	VoidPtr ke_new_ke_heap(const SizeT sz, const bool rw, const bool user)
+	VoidPtr mm_new_ke_heap(const SizeT sz, const bool rw, const bool user)
 	{
 		auto szFix = sz;
 
@@ -83,8 +83,8 @@ namespace Kernel
 
 		auto wrapper = kHeapPageManager.Request(rw, user, false, szFix);
 
-		Detail::HeapInformationBlockPtr heapInfo =
-			reinterpret_cast<Detail::HeapInformationBlockPtr>(
+		Details::HEAP_INFORMATION_BLOCK_PTR heapInfo =
+			reinterpret_cast<Details::HEAP_INFORMATION_BLOCK_PTR>(
 				wrapper.VirtualAddress());
 
 		heapInfo->fTargetPtrSize = szFix;
@@ -96,24 +96,24 @@ namespace Kernel
 		++kHeapCount;
 
 		return reinterpret_cast<VoidPtr>(wrapper.VirtualAddress() +
-										 sizeof(Detail::HeapInformationBlock));
+										 sizeof(Details::HEAP_INFORMATION_BLOCK));
 	}
 
 	/// @brief Makes a page heap.
 	/// @param heapPtr
 	/// @return
-	Int32 ke_make_ke_page(VoidPtr heapPtr)
+	Int32 mm_make_ke_page(VoidPtr heapPtr)
 	{
 		if (kHeapCount < 1)
 			return -kErrorInternal;
-		if (((IntPtr)heapPtr - sizeof(Detail::HeapInformationBlock)) <= 0)
+		if (((IntPtr)heapPtr - sizeof(Details::HEAP_INFORMATION_BLOCK)) <= 0)
 			return -kErrorInternal;
 		if (((IntPtr)heapPtr - kBadPtr) < 0)
 			return -kErrorInternal;
 
-		Detail::HeapInformationBlockPtr heapInfoBlk =
-			reinterpret_cast<Detail::HeapInformationBlockPtr>(
-				(UIntPtr)heapPtr - sizeof(Detail::HeapInformationBlock));
+		Details::HEAP_INFORMATION_BLOCK_PTR heapInfoBlk =
+			reinterpret_cast<Details::HEAP_INFORMATION_BLOCK_PTR>(
+				(UIntPtr)heapPtr - sizeof(Details::HEAP_INFORMATION_BLOCK));
 
 		heapInfoBlk->fPagePtr = 1;
 
@@ -123,18 +123,18 @@ namespace Kernel
 	/// @brief Declare pointer as free.
 	/// @param heapPtr the pointer.
 	/// @return
-	Int32 ke_delete_ke_heap(VoidPtr heapPtr)
+	Int32 mm_delete_ke_heap(VoidPtr heapPtr)
 	{
 		if (kHeapCount < 1)
 			return -kErrorInternal;
-		if (((IntPtr)heapPtr - sizeof(Detail::HeapInformationBlock)) <= 0)
+		if (((IntPtr)heapPtr - sizeof(Details::HEAP_INFORMATION_BLOCK)) <= 0)
 			return -kErrorInternal;
 		if (((IntPtr)heapPtr - kBadPtr) < 0)
 			return -kErrorInternal;
 
-		Detail::HeapInformationBlockPtr heapInfoBlk =
-			reinterpret_cast<Detail::HeapInformationBlockPtr>(
-				(UIntPtr)heapPtr - sizeof(Detail::HeapInformationBlock));
+		Details::HEAP_INFORMATION_BLOCK_PTR heapInfoBlk =
+			reinterpret_cast<Details::HEAP_INFORMATION_BLOCK_PTR>(
+				(UIntPtr)heapPtr - sizeof(Details::HEAP_INFORMATION_BLOCK));
 
 		if (heapInfoBlk && heapInfoBlk->fMagic == kKernelHeapMagic)
 		{
@@ -181,9 +181,9 @@ namespace Kernel
 
 		if (heapPtr)
 		{
-			Detail::HeapInformationBlockPtr virtualAddress =
-				reinterpret_cast<Detail::HeapInformationBlockPtr>(
-					(UIntPtr)heapPtr - sizeof(Detail::HeapInformationBlock));
+			Details::HEAP_INFORMATION_BLOCK_PTR virtualAddress =
+				reinterpret_cast<Details::HEAP_INFORMATION_BLOCK_PTR>(
+					(UIntPtr)heapPtr - sizeof(Details::HEAP_INFORMATION_BLOCK));
 
 			if (virtualAddress->fPresent && virtualAddress->fMagic == kKernelHeapMagic)
 			{
@@ -197,13 +197,13 @@ namespace Kernel
 	/// @brief Protect the heap with a CRC value.
 	/// @param heapPtr HIB pointer.
 	/// @return if it valid: point has crc now., otherwise fail.
-	Boolean ke_protect_ke_heap(VoidPtr heapPtr)
+	Boolean mm_protect_ke_heap(VoidPtr heapPtr)
 	{
 		if (heapPtr)
 		{
-			Detail::HeapInformationBlockPtr heapInfoBlk =
-				reinterpret_cast<Detail::HeapInformationBlockPtr>(
-					(UIntPtr)heapPtr - sizeof(Detail::HeapInformationBlock));
+			Details::HEAP_INFORMATION_BLOCK_PTR heapInfoBlk =
+				reinterpret_cast<Details::HEAP_INFORMATION_BLOCK_PTR>(
+					(UIntPtr)heapPtr - sizeof(Details::HEAP_INFORMATION_BLOCK));
 
 			if (heapInfoBlk->fPresent && kKernelHeapMagic == heapInfoBlk->fMagic)
 			{
diff --git a/Kernel/Sources/Main.cxx b/Kernel/Sources/Main.cxx
index 318cbe3f..79febc15 100644
--- a/Kernel/Sources/Main.cxx
+++ b/Kernel/Sources/Main.cxx
@@ -190,8 +190,7 @@ namespace Kernel::Detail
 	{
 
 		Kernel::UserView::The()->fRootUser = new User(RingKind::kRingSuperUser, kSuperUser);
-
-		Kernel::UserView::The()->LogIn(Kernel::UserView::The()->fRootUser, nullptr);
+		Kernel::UserView::The()->LogIn(Kernel::UserView::The()->fRootUser, "");
 
 		Kernel::kcout << "newoskrnl: " << cKernelVersion.GetKey().CData() << ": " << Kernel::number(cKernelVersion.GetValue()) << Kernel::endl;
 	}
diff --git a/Kernel/Sources/New+Delete.cxx b/Kernel/Sources/New+Delete.cxx
index 2921e079..b43fafbc 100644
--- a/Kernel/Sources/New+Delete.cxx
+++ b/Kernel/Sources/New+Delete.cxx
@@ -12,7 +12,7 @@ void* operator new[](size_t sz)
 	if (sz == 0)
 		++sz;
 
-	return Kernel::ke_new_ke_heap(sz, true, false);
+	return Kernel::mm_new_ke_heap(sz, true, false);
 }
 
 void* operator new(size_t sz)
@@ -20,7 +20,7 @@ void* operator new(size_t sz)
 	if (sz == 0)
 		++sz;
 
-	return Kernel::ke_new_ke_heap(sz, true, false);
+	return Kernel::mm_new_ke_heap(sz, true, false);
 }
 
 void operator delete[](void* ptr)
@@ -28,7 +28,7 @@ void operator delete[](void* ptr)
 	if (ptr == nullptr)
 		return;
 
-	Kernel::ke_delete_ke_heap(ptr);
+	Kernel::mm_delete_ke_heap(ptr);
 }
 
 void operator delete(void* ptr)
@@ -36,7 +36,7 @@ void operator delete(void* ptr)
 	if (ptr == nullptr)
 		return;
 
-	Kernel::ke_delete_ke_heap(ptr);
+	Kernel::mm_delete_ke_heap(ptr);
 }
 
 void operator delete(void* ptr, size_t sz)
@@ -46,5 +46,5 @@ void operator delete(void* ptr, size_t sz)
 
 	NEWOS_UNUSED(sz);
 
-	Kernel::ke_delete_ke_heap(ptr);
+	Kernel::mm_delete_ke_heap(ptr);
 }
diff --git a/Kernel/Sources/PEFCodeManager.cxx b/Kernel/Sources/PEFCodeManager.cxx
index 8b1918ef..223505b8 100644
--- a/Kernel/Sources/PEFCodeManager.cxx
+++ b/Kernel/Sources/PEFCodeManager.cxx
@@ -85,7 +85,7 @@ namespace Kernel
 			kcout << "CodeManager: Warning: Executable format error!\n";
 			fBad = true;
 
-			ke_delete_ke_heap(fCachedBlob);
+			mm_delete_ke_heap(fCachedBlob);
 
 			fCachedBlob = nullptr;
 		}
@@ -95,7 +95,7 @@ namespace Kernel
 	PEFLoader::~PEFLoader()
 	{
 		if (fCachedBlob)
-			ke_delete_ke_heap(fCachedBlob);
+			mm_delete_ke_heap(fCachedBlob);
 
 		fFile.Delete();
 	}
@@ -160,7 +160,7 @@ namespace Kernel
 					{
 						if (!this->fFatBinary)
 						{
-							ke_delete_ke_heap(blob);
+							mm_delete_ke_heap(blob);
 							return nullptr;
 						}
 					}
@@ -169,13 +169,13 @@ namespace Kernel
 
 					rt_copy_memory((VoidPtr)((Char*)blob + sizeof(PEFCommandHeader)), blobRet, container_header->Size);
 
-					ke_delete_ke_heap(blob);
+					mm_delete_ke_heap(blob);
 					return blobRet;
 				}
 			}
 		}
 
-		ke_delete_ke_heap(blob);
+		mm_delete_ke_heap(blob);
 		return nullptr;
 	}
 
@@ -219,18 +219,18 @@ namespace Kernel
 		return fPath.Leak().CData();
 	}
 
-	const char* PEFLoader::FormatAsString()
+	const char* PEFLoader::AsString()
 	{
 #ifdef __32x0__
-		return "32x0 PEF.";
+		return "32x0 PEF format.";
 #elif defined(__64x0__)
-		return "64x0 PEF.";
+		return "64x0 PEF format.";
 #elif defined(__x86_64__)
-		return "x86_64 PEF.";
+		return "x86_64 PEF format.";
 #elif defined(__powerpc64__)
-		return "POWER PEF.";
+		return "POWER PEF format.";
 #else
-		return "Unknown PEF.";
+		return "Unknown PEF format.";
 #endif // __32x0__ || __64x0__ || __x86_64__ || __powerpc64__
 	}
 
diff --git a/Kernel/Sources/ProcessScheduler.cxx b/Kernel/Sources/ProcessScheduler.cxx
index cccd8979..7002bd1f 100644
--- a/Kernel/Sources/ProcessScheduler.cxx
+++ b/Kernel/Sources/ProcessScheduler.cxx
@@ -185,10 +185,10 @@ namespace Kernel
 
 		//! Delete image if not done already.
 		if (this->Image)
-			ke_delete_ke_heap(this->Image);
+			mm_delete_ke_heap(this->Image);
 
 		if (this->StackFrame)
-			ke_delete_ke_heap((VoidPtr)this->StackFrame);
+			mm_delete_ke_heap((VoidPtr)this->StackFrame);
 
 		this->Image		 = nullptr;
 		this->StackFrame = nullptr;
@@ -231,7 +231,7 @@ namespace Kernel
 		}
 
 		process.Leak().StackFrame = reinterpret_cast<HAL::StackFrame*>(
-			ke_new_ke_heap(sizeof(HAL::StackFrame), true, false));
+			mm_new_ke_heap(sizeof(HAL::StackFrame), true, false));
 
 		MUST_PASS(process.Leak().StackFrame);