Kernel: lots of fixes and improvements.

Signed-off-by: Amlal El Mahrouss <amlal.elmahrouss@icloud.com>

16 files changed, 85 insertions, 71 deletions

diff --git a/dev/ZBAKit/amd64-efi.make b/dev/ZBAKit/amd64-efi.make
index a27293ce..0ef4cf18 100644
--- a/dev/ZBAKit/amd64-efi.make
+++ b/dev/ZBAKit/amd64-efi.make
@@ -29,12 +29,12 @@ IMG=epm-master-1.img
 IMG_2=epm-slave.img
 IMG_3=epm-master-2.img
 
-EMU_FLAGS=-net none -smp 4 -m 8G -M q35 \
+EMU_FLAGS=-net none -smp 1 -m 8G -M q35 \
 			-bios $(BIOS) -drive \
 			file=fat:rw:src/Root/,index=2,format=raw \
 			-drive id=disk_2,file=$(IMG),if=none \
             -device ahci,id=ahci \
-            -device ide-hd,drive=disk_2,bus=ahci.0 -d int
+            -device ide-hd,drive=disk_2,bus=ahci.0 -d int -no-shutdown -no-reboot 
 
 LD_FLAGS=-e Main --subsystem=10
 
diff --git a/dev/ZKAKit/ArchKit/ArchKit.h b/dev/ZKAKit/ArchKit/ArchKit.h
index 1b9e8d1c..b58edaa8 100644
--- a/dev/ZKAKit/ArchKit/ArchKit.h
+++ b/dev/ZKAKit/ArchKit/ArchKit.h
@@ -82,4 +82,4 @@ inline Kernel::Array<HAL_SYSCALL_RECORD,
 					 kKernelMaxSystemCalls>
 	kKerncalls;
 
-EXTERN_C Kernel::HAL::StackFramePtr mp_get_current_context();
+EXTERN_C Kernel::HAL::StackFramePtr mp_get_current_context(Kernel::Int64 pid);
diff --git a/dev/ZKAKit/HALKit/AMD64/HalCoreInterruptHandlerAMD64.cc b/dev/ZKAKit/HALKit/AMD64/HalCoreInterruptHandlerAMD64.cc
index 2cef8125..f6956793 100644
--- a/dev/ZKAKit/HALKit/AMD64/HalCoreInterruptHandlerAMD64.cc
+++ b/dev/ZKAKit/HALKit/AMD64/HalCoreInterruptHandlerAMD64.cc
@@ -12,6 +12,7 @@
 /// @param rsp
 EXTERN_C void idt_handle_gpf(Kernel::UIntPtr rsp)
 {
+	kcout << "Kernel: GPF.\r";
 	Kernel::UserProcessScheduler::The().GetCurrentProcess().Leak().Crash();
 }
 
@@ -19,12 +20,14 @@ EXTERN_C void idt_handle_gpf(Kernel::UIntPtr rsp)
 /// @param rsp
 EXTERN_C void idt_handle_pf(Kernel::UIntPtr rsp)
 {
+	kcout << "Kernel: Page Fault.\r";
 	Kernel::UserProcessScheduler::The().GetCurrentProcess().Leak().Crash();
 }
 
 /// @brief Handle scheduler interrupt.
 EXTERN_C void idt_handle_scheduler(Kernel::UIntPtr rsp)
 {
+	kcout << "Kernel: IRQ0.\r";
 	Kernel::UserProcessHelper::StartScheduling();
 }
 
@@ -32,6 +35,7 @@ EXTERN_C void idt_handle_scheduler(Kernel::UIntPtr rsp)
 /// @param rsp
 EXTERN_C void idt_handle_math(Kernel::UIntPtr rsp)
 {
+	kcout << "Kernel: Math.\r";
 	Kernel::UserProcessScheduler::The().GetCurrentProcess().Leak().Crash();
 }
 
@@ -39,6 +43,7 @@ EXTERN_C void idt_handle_math(Kernel::UIntPtr rsp)
 /// @param rsp
 EXTERN_C void idt_handle_generic(Kernel::UIntPtr rsp)
 {
+	kcout << "Kernel: Generic Fault.\r";
 	Kernel::UserProcessScheduler::The().GetCurrentProcess().Leak().Crash();
 }
 
@@ -46,6 +51,7 @@ EXTERN_C void idt_handle_generic(Kernel::UIntPtr rsp)
 /// @param rsp
 EXTERN_C void idt_handle_ud(Kernel::UIntPtr rsp)
 {
+	kcout << "Kernel: Undefined Opcode.\r";
 	Kernel::UserProcessScheduler::The().GetCurrentProcess().Leak().Crash();
 }
 
diff --git a/dev/ZKAKit/HALKit/AMD64/HalCoreMPScheduler.cc b/dev/ZKAKit/HALKit/AMD64/HalCoreMPScheduler.cc
index b3718b96..d484c2a0 100644
--- a/dev/ZKAKit/HALKit/AMD64/HalCoreMPScheduler.cc
+++ b/dev/ZKAKit/HALKit/AMD64/HalCoreMPScheduler.cc
@@ -133,8 +133,6 @@ namespace Kernel::HAL
 		Kernel::ke_dma_write(targetAddress, kAPIC_ICR_Low, kAPIC_EIPI_Vector | vector);
 	}
 
-	EXTERN_C Bool mp_register_process(VoidPtr image, UInt8* stack_ptr, HAL::StackFramePtr stack_frame);
-
 	STATIC struct PROCESS_CONTROL_BLOCK final
 	{
 		HAL::StackFramePtr f_Frame;
@@ -142,18 +140,21 @@ namespace Kernel::HAL
 		VoidPtr			   f_Image;
 	} kProcessBlocks[kSchedProcessLimitPerTeam] = {0};
 
-	EXTERN_C HAL::StackFramePtr mp_get_current_context(Void)
+	EXTERN_C HAL::StackFramePtr mp_get_current_context(Int64 pid)
 	{
-		return kProcessBlocks[UserProcessScheduler::The().GetCurrentProcess().Leak().ProcessId % kSchedProcessLimitPerTeam].f_Frame;
+		const auto process_index = pid % kSchedProcessLimitPerTeam;
+		return kProcessBlocks[process_index].f_Frame;
 	}
 
-	EXTERN_C Bool mp_register_process(VoidPtr image, UInt8* stack_ptr, HAL::StackFramePtr stack_frame)
+	EXTERN_C Bool mp_register_process(VoidPtr image, UInt8* stack_ptr, HAL::StackFramePtr stack_frame, ProcessID pid)
 	{
 		MUST_PASS(image && stack_ptr && stack_frame);
 
-		kProcessBlocks[UserProcessScheduler::The().GetCurrentProcess().Leak().ProcessId % kSchedProcessLimitPerTeam].f_Frame = stack_frame;
-		kProcessBlocks[UserProcessScheduler::The().GetCurrentProcess().Leak().ProcessId % kSchedProcessLimitPerTeam].f_Stack = stack_ptr;
-		kProcessBlocks[UserProcessScheduler::The().GetCurrentProcess().Leak().ProcessId % kSchedProcessLimitPerTeam].f_Image = image;
+		const auto process_index = pid % kSchedProcessLimitPerTeam;
+
+		kProcessBlocks[process_index].f_Frame = stack_frame;
+		kProcessBlocks[process_index].f_Stack = stack_ptr;
+		kProcessBlocks[process_index].f_Image = image;
 
 		return Yes;
 	}
diff --git a/dev/ZKAKit/HALKit/AMD64/HalDescriptorLoader.cc b/dev/ZKAKit/HALKit/AMD64/HalDescriptorLoader.cc
index fe6491c6..bfa9bcf3 100644
--- a/dev/ZKAKit/HALKit/AMD64/HalDescriptorLoader.cc
+++ b/dev/ZKAKit/HALKit/AMD64/HalDescriptorLoader.cc
@@ -7,14 +7,14 @@
 #include <ArchKit/ArchKit.h>
 #include <HALKit/AMD64/Processor.h>
 
-#define kPITDefaultTicks (1000U)
+#define kPITDefaultTicks (100U)
 
 namespace Kernel::HAL
 {
 	namespace Detail
 	{
 		STATIC ::Kernel::Detail::AMD64::InterruptDescriptorAMD64
-			kInterruptVectorTable[kKernelIdtSize];
+			kInterruptVectorTable[kKernelIdtSize] = { };
 
 		STATIC void hal_set_irq_mask(UInt8 irql);
 		STATIC void hal_clear_irq_mask(UInt8 irql);
@@ -84,11 +84,13 @@ namespace Kernel::HAL
 
 	Void IDTLoader::Load(Register64& idt)
 	{
+		rt_cli();
+
 		const Int16 kPITTickForScheduler = kPITDefaultTicks;
 
 		volatile ::Kernel::UIntPtr** ptr_ivt = (volatile ::Kernel::UIntPtr**)idt.Base;
 
-		for (UInt16 idt_indx = 0; idt_indx < kKernelIdtSize; ++idt_indx)
+		for (SizeT idt_indx = 0; idt_indx < kKernelIdtSize; ++idt_indx)
 		{
 			Detail::kInterruptVectorTable[idt_indx].Selector	   = kIDTSelector;
 			Detail::kInterruptVectorTable[idt_indx].Ist			   = 0;
@@ -103,11 +105,13 @@ namespace Kernel::HAL
 
 		idt.Base  = (UIntPtr)&Detail::kInterruptVectorTable[0];
 		idt.Limit = sizeof(::Kernel::Detail::AMD64::InterruptDescriptorAMD64) *
-					(kKernelIdtSize)-1;
+					(kKernelIdtSize);
 
 		hal_load_idt(idt);
 
 		Detail::hal_enable_pit(kPITTickForScheduler);
+
+		rt_sti();
 	}
 
 	void GDTLoader::Load(Ref<RegisterGDT>& gdt)
diff --git a/dev/ZKAKit/HALKit/AMD64/HalInterruptAPI.asm b/dev/ZKAKit/HALKit/AMD64/HalInterruptAPI.asm
index d25d34f6..9121edb9 100644
--- a/dev/ZKAKit/HALKit/AMD64/HalInterruptAPI.asm
+++ b/dev/ZKAKit/HALKit/AMD64/HalInterruptAPI.asm
@@ -340,8 +340,6 @@ mp_system_call_handler:
     o64 sysret
 
 hal_load_idt:
-    cli
-
     lidt [rcx]
 
     ; Master PIC initialization
@@ -369,8 +367,6 @@ hal_load_idt:
     out 0x21, al
     out 0xA1, al
 
-    sti
-
     ret
 
 section .data
diff --git a/dev/ZKAKit/HALKit/AMD64/HalKernelMain.cc b/dev/ZKAKit/HALKit/AMD64/HalKernelMain.cc
index 2e78a292..cebe2fe6 100644
--- a/dev/ZKAKit/HALKit/AMD64/HalKernelMain.cc
+++ b/dev/ZKAKit/HALKit/AMD64/HalKernelMain.cc
@@ -20,22 +20,22 @@ EXTERN_C Kernel::Char mp_user_switch_proc_stack_begin[];
 EXTERN_C Kernel::MainKind __CTOR_LIST__[];
 EXTERN_C Kernel::MainKind __DTOR_LIST__[];
 
+namespace Kernel
+{
+	EXTERN ProcessID kProcessIDCounter;
+}
+
 STATIC Kernel::Void hal_init_cxx_ctors()
 {
+	Kernel::kProcessIDCounter = 0UL;
+
 	for (Kernel::SizeT index = 0UL; __CTOR_LIST__[index] != __DTOR_LIST__[0]; ++index)
 	{
 		Kernel::MainKind constructor_cxx = (Kernel::MainKind)__CTOR_LIST__[index];
 		constructor_cxx();
-
-		kcout << "Called constrcutor.\r";
 	}
 }
 
-namespace Kernel
-{
-	EXTERN ProcessID kProcessIDCounter;
-}
-
 /// @brief Kernel init procedure.
 EXTERN_C void hal_init_platform(
 	Kernel::HEL::HANDOVER_INFO_HEADER* HandoverHeader)
@@ -50,8 +50,6 @@ EXTERN_C void hal_init_platform(
 
 	hal_init_cxx_ctors();
 
-	Kernel::kProcessIDCounter = 0UL;
-
 	/************************************** */
 	/*     INITIALIZE BIT MAP.              */
 	/************************************** */
@@ -93,22 +91,23 @@ EXTERN_C Kernel::Void hal_real_init(Kernel::Void) noexcept
 	/* Initialize filesystem. */
 	Kernel::NeFileSystemMgr::Mount(new Kernel::NeFileSystemMgr());
 
+	const Kernel::Char process_name[] = "Kernel";
+
 	Kernel::rtl_create_process([]() -> void {
 		while (Yes)
 			;
-	}, "RtlProcess");
+	}, process_name);
+
+	/* Load interrupts and start SMP. */
 
-	/* Start any cores. */
 	if (kHandoverHeader->f_HardwareTables.f_MultiProcessingEnabled)
 		Kernel::HAL::mp_get_cores(kHandoverHeader->f_HardwareTables.f_VendorPtr);
 
 	Kernel::HAL::Register64 idt_reg;
 	idt_reg.Base = (Kernel::UIntPtr)kInterruptVectorTable;
 
-	/* Load interrupts. */
 	Kernel::HAL::IDTLoader idt_loader;
 	idt_loader.Load(idt_reg);
 
-	while (Yes)
-		;
+	Kernel::ke_stop(RUNTIME_CHECK_BOOTSTRAP);
 }
diff --git a/dev/ZKAKit/HALKit/AMD64/Processor.h b/dev/ZKAKit/HALKit/AMD64/Processor.h
index c854969b..9d0a989c 100644
--- a/dev/ZKAKit/HALKit/AMD64/Processor.h
+++ b/dev/ZKAKit/HALKit/AMD64/Processor.h
@@ -306,8 +306,8 @@ EXTERN_C Kernel::Void idt_handle_gpf(Kernel::UIntPtr rsp);
 EXTERN_C Kernel::Void idt_handle_math(Kernel::UIntPtr rsp);
 EXTERN_C Kernel::Void idt_handle_pf(Kernel::UIntPtr rsp);
 
-EXTERN_C Kernel::Void hal_load_idt(Kernel::HAL::Register64 ptr);
-EXTERN_C Kernel::Void hal_load_gdt(Kernel::HAL::RegisterGDT ptr);
+EXTERN_C ATTRIBUTE(naked) Kernel::Void hal_load_idt(Kernel::HAL::Register64 ptr);
+EXTERN_C ATTRIBUTE(naked) Kernel::Void hal_load_gdt(Kernel::HAL::RegisterGDT ptr);
 
 inline Kernel::VoidPtr kKernelBitMpStart = nullptr;
 inline Kernel::UIntPtr kKernelBitMpSize	 = 0UL;
diff --git a/dev/ZKAKit/HALKit/ARM64/HalCoreMPScheduler.cc b/dev/ZKAKit/HALKit/ARM64/HalCoreMPScheduler.cc
index 28d36c5a..c6425cf1 100644
--- a/dev/ZKAKit/HALKit/ARM64/HalCoreMPScheduler.cc
+++ b/dev/ZKAKit/HALKit/ARM64/HalCoreMPScheduler.cc
@@ -16,12 +16,12 @@ STATIC struct PROCESS_CONTROL_BLOCK final
 	VoidPtr			   f_Image;
 } kProcessBlocks[kSchedProcessLimitPerTeam] = {0};
 
-EXTERN_C HAL::StackFramePtr mp_get_current_context(Void)
+EXTERN_C HAL::StackFramePtr mp_get_current_context(ProcessID pid)
 {
-	return kProcessBlocks[UserProcessScheduler::The().GetCurrentProcess().Leak().ProcessId % kSchedProcessLimitPerTeam].f_Frame;
+	return kProcessBlocks[pid % kSchedProcessLimitPerTeam].f_Frame;
 }
 
-EXTERN_C Bool mp_register_process(VoidPtr image, UInt8* stack_ptr, HAL::StackFramePtr stack_frame)
+EXTERN_C Bool mp_register_process(VoidPtr image, UInt8* stack_ptr, HAL::StackFramePtr stack_frame, ProcessID pid)
 {
 	MUST_PASS(image && stack_ptr && stack_frame);
 	return No;
diff --git a/dev/ZKAKit/KernelKit/HardwareThreadScheduler.h b/dev/ZKAKit/KernelKit/HardwareThreadScheduler.h
index 07115519..4229df82 100644
--- a/dev/ZKAKit/KernelKit/HardwareThreadScheduler.h
+++ b/dev/ZKAKit/KernelKit/HardwareThreadScheduler.h
@@ -61,7 +61,7 @@ namespace Kernel
 		void Busy(const bool busy = false) noexcept;
 
 	public:
-		bool Switch(VoidPtr image, Ptr8 stack_ptr, HAL::StackFramePtr frame);
+		bool Switch(VoidPtr image, Ptr8 stack_ptr, HAL::StackFramePtr frame, const ProcessID& pid);
 		bool IsWakeup() noexcept;
 
 	public:
diff --git a/dev/ZKAKit/src/BitMapMgr.cc b/dev/ZKAKit/src/BitMapMgr.cc
index bab9285b..759d4c4e 100644
--- a/dev/ZKAKit/src/BitMapMgr.cc
+++ b/dev/ZKAKit/src/BitMapMgr.cc
@@ -67,7 +67,6 @@ namespace Kernel
 
 				UInt32 MakeMMFlags(Bool wr, Bool user)
 				{
-
 					UInt32 flags = kMMFlagsPresent;
 
 					if (wr)
@@ -171,6 +170,7 @@ namespace Kernel
 			if (!page_ptr)
 				return No;
 
+
 			Detail::IBitMapAllocator traits;
 			Bool					 ret = traits.FreeBitMap(page_ptr);
 
diff --git a/dev/ZKAKit/src/CodeMgr.cc b/dev/ZKAKit/src/CodeMgr.cc
index 784ea38c..cde249ac 100644
--- a/dev/ZKAKit/src/CodeMgr.cc
+++ b/dev/ZKAKit/src/CodeMgr.cc
@@ -16,24 +16,23 @@ namespace Kernel
 	/// @return if the process was started or not.
 	ProcessID rtl_create_process(MainKind main, const Char* process_name) noexcept
 	{
-		kcout << "Validating process...\r";
+		kcout << "Validating process header...\r";
 
 		if (!main)
 			return No;
 
-		UserProcess* proc = new UserProcess{reinterpret_cast<VoidPtr>(main)};
-
+		static UserProcess proc;
+		
 		kcout << "Setting-up process data...\r";
 
-		proc->Kind		= UserProcess::kExectuableKind;
-		proc->StackSize = kib_cast(4);
-
-		rt_set_memory(proc->Name, 0, kProcessNameLen);
-		rt_copy_memory((VoidPtr)process_name, proc->Name, rt_string_len(process_name));
+		proc.Code = reinterpret_cast<VoidPtr>(main);
+		proc.Kind		= UserProcess::kExectuableKind;
+		proc.StackSize = kib_cast(16);
 
-		ProcessID id = UserProcessScheduler::The().Add(proc);
+		rt_set_memory(proc.Name, 0, kProcessNameLen);
+		rt_copy_memory((VoidPtr)process_name, proc.Name, rt_string_len(process_name));
 
-		delete proc;
+		ProcessID id = UserProcessScheduler::The().Add(&proc);
 
 		return id;
 	}
diff --git a/dev/ZKAKit/src/HardwareThreadScheduler.cc b/dev/ZKAKit/src/HardwareThreadScheduler.cc
index 7651185d..48fcd5b4 100644
--- a/dev/ZKAKit/src/HardwareThreadScheduler.cc
+++ b/dev/ZKAKit/src/HardwareThreadScheduler.cc
@@ -90,13 +90,13 @@ namespace Kernel
 	/// @note Those symbols are needed in order to switch and validate the stack.
 
 	EXTERN Bool	  hal_check_stack(HAL::StackFramePtr frame_ptr);
-	EXTERN_C Bool mp_register_process(VoidPtr image, Ptr8 stack_ptr, HAL::StackFramePtr frame_ptr);
+	EXTERN_C Bool mp_register_process(VoidPtr image, Ptr8 stack_ptr, HAL::StackFramePtr frame, ProcessID pid);
 
 	/// @brief Switch to hardware thread.
 	/// @param stack the new hardware thread.
 	/// @retval true stack was changed, code is running.
 	/// @retval false stack is invalid, previous code is running.
-	Bool HardwareThread::Switch(VoidPtr image, Ptr8 stack_ptr, HAL::StackFramePtr frame)
+	Bool HardwareThread::Switch(VoidPtr image, Ptr8 stack_ptr, HAL::StackFramePtr frame, const ProcessID& pid)
 	{
 		if (!frame ||
 			!image ||
@@ -112,9 +112,11 @@ namespace Kernel
 		if (!hal_check_stack(frame))
 			return No;
 
-		fStack = frame;
+		this->fStack = frame;
+		this->fSourcePID = pid;
 
-		Bool ret = mp_register_process(image, stack_ptr, fStack);
+
+		Bool ret = mp_register_process(image, stack_ptr, fStack, this->fSourcePID);
 
 		if (ret)
 			this->Busy(true);
diff --git a/dev/ZKAKit/src/Heap.cc b/dev/ZKAKit/src/Heap.cc
index 240cee6d..9dfb9cca 100644
--- a/dev/ZKAKit/src/Heap.cc
+++ b/dev/ZKAKit/src/Heap.cc
@@ -253,7 +253,7 @@ namespace Kernel
 			PageMgr heap_mgr;
 			heap_mgr.Free(pteAddress);
 
-			kcout << "Freed Heap address: " << hex_number(reinterpret_cast<UIntPtr>(heap_info_ptr)) << endl;
+			kcout << "Freed Heap address successfully." << endl;
 
 			return kErrorSuccess;
 		}
diff --git a/dev/ZKAKit/src/PEFCodeMgr.cc b/dev/ZKAKit/src/PEFCodeMgr.cc
index f929a01f..38ab45bc 100644
--- a/dev/ZKAKit/src/PEFCodeMgr.cc
+++ b/dev/ZKAKit/src/PEFCodeMgr.cc
@@ -226,7 +226,7 @@ namespace Kernel
 #elif defined(__x86_64__)
 		return "x86_64 PEF executable.";
 #elif defined(__aarch64__)
-		return "aarch64 PEF executable.";
+		return "AARCH64 PEF executable.";
 #elif defined(__powerpc64__)
 		return "POWER64 PEF executable.";
 #else
@@ -253,26 +253,27 @@ namespace Kernel
 			if (errOrStart.Error() != kErrorSuccess)
 				return No;
 
-			UserProcess* proc = new UserProcess{errOrStart.Leak().Leak()};
+			STATIC UserProcess proc;
 
-			proc->Kind		  = procKind;
-			proc->ExecImg	  = exec.GetBlob().Leak().Leak();
-			proc->StackSize	  = *(UIntPtr*)exec.FindSymbol(kPefStackSizeSymbol, kPefData);
-			proc->MemoryLimit = *(UIntPtr*)exec.FindSymbol(kPefHeapSizeSymbol, kPefData);
-			proc->PTime		  = 0UL;
+			proc.Kind		  = procKind;
+			proc.ExecImg	  = errOrStart.Leak().Leak();
+			proc.ExecImg	  = exec.GetBlob().Leak().Leak();
+			proc.StackSize	  = *(UIntPtr*)exec.FindSymbol(kPefStackSizeSymbol, kPefData);
+			proc.MemoryLimit = *(UIntPtr*)exec.FindSymbol(kPefHeapSizeSymbol, kPefData);
+			proc.PTime		  = 0UL;
 
-			rt_set_memory(proc->Name, 0, kProcessNameLen);
+			rt_set_memory(proc.Name, 0, kProcessNameLen);
 
 			if (exec.FindSymbol(kPefNameSymbol, kPefData))
-				rt_copy_memory(exec.FindSymbol(kPefNameSymbol, kPefData), proc->Name, rt_string_len((Char*)exec.FindSymbol(kPefNameSymbol, kPefData)));
+				rt_copy_memory(exec.FindSymbol(kPefNameSymbol, kPefData), proc.Name, rt_string_len((Char*)exec.FindSymbol(kPefNameSymbol, kPefData)));
 
-			if (!proc->StackSize)
+			if (!proc.StackSize)
 			{
 				const auto cDefaultStackSizeMib = 8;
-				proc->StackSize					= mib_cast(cDefaultStackSizeMib);
+				proc.StackSize					= mib_cast(cDefaultStackSizeMib);
 			}
 
-			return UserProcessScheduler::The().Add(proc);
+			return UserProcessScheduler::The().Add(&proc);
 		}
 	} // namespace Utils
 } // namespace Kernel
diff --git a/dev/ZKAKit/src/UserProcessScheduler.cc b/dev/ZKAKit/src/UserProcessScheduler.cc
index 4550af4e..e5bcd1c2 100644
--- a/dev/ZKAKit/src/UserProcessScheduler.cc
+++ b/dev/ZKAKit/src/UserProcessScheduler.cc
@@ -325,6 +325,12 @@ namespace Kernel
 
 	ProcessID UserProcessScheduler::Add(UserProcess* process)
 	{
+		if (*process->Name == 0)
+		{
+			Char process_name[] = "System Process";
+			rt_copy_memory((VoidPtr)process_name, process->Name, rt_string_len(process_name));
+		}
+
 #ifdef __ZKA_AMD64__
 		process->VMRegister = mm_new_heap(sizeof(PDE), No, Yes);
 
@@ -353,7 +359,7 @@ namespace Kernel
 			process->PefDLLDelegate = rtl_init_dll(process);
 			MUST_PASS(process->PefDLLDelegate);
 
-			kcout << "Create delegate dylib for: " << process->Name << endl;
+			kcout << "Create DLL Delegate for: " << process->Name << endl;
 		}
 
 		process->StackReserve = new UInt8[process->StackSize];
@@ -370,7 +376,7 @@ namespace Kernel
 			return -kErrorProcessFault;
 		}
 
-		kcout << "Created stack reserve for: " << process->Name << endl;
+		kcout << "Create stack reserve for: " << process->Name << endl;
 
 		auto pid = kProcessIDCounter;
 
@@ -575,8 +581,8 @@ namespace Kernel
 				////////////////////////////////////////////////////////////
 
 				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);
+				HardwareThreadScheduler::The()[index].Leak()->fPTime = UserProcessScheduler::The().CurrentTeam().AsArray()[new_pid].PTime;
+				Bool ret											 = HardwareThreadScheduler::The()[index].Leak()->Switch(image_ptr, stack, frame_ptr, new_pid);
 
 				////////////////////////////////////////////////////////////
 				///	Rollback on fail.    								 ///