Refactor kernel refactors and worked on fixing the GPF on user mode switch.

TODO: Re-implement the mm_map_page function.

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

8 files changed, 73 insertions, 91 deletions

diff --git a/dev/zka/HALKit/AMD64/HalKernelMain.cxx b/dev/zka/HALKit/AMD64/HalKernelMain.cxx
index 767cc903..1ed11953 100644
--- a/dev/zka/HALKit/AMD64/HalKernelMain.cxx
+++ b/dev/zka/HALKit/AMD64/HalKernelMain.cxx
@@ -29,6 +29,7 @@ namespace Kernel::HAL
 } // namespace Kernel::HAL
 
 EXTERN_C Kernel::VoidPtr kInterruptVectorTable[];
+EXTERN_C Kernel::VoidPtr mp_user_switch_proc;
 
 /// @brief Kernel init procedure.
 EXTERN_C void hal_init_platform(
@@ -89,6 +90,8 @@ EXTERN_C Kernel::Void hal_real_init(Kernel::Void) noexcept
 	Kernel::NeFileSystemMgr* mgr = Kernel::mm_new_class<Kernel::NeFileSystemMgr>();
 	Kernel::NeFileSystemMgr::Mount(mgr);
 
+	Kernel::HAL::mm_map_page(mp_user_switch_proc, Kernel::HAL::eFlagsUser);
+
 	mp_do_user_switch();
 
 	Kernel::ke_stop(RUNTIME_CHECK_BOOTSTRAP);
diff --git a/dev/zka/HALKit/AMD64/ReadMe.md b/dev/zka/HALKit/AMD64/ReadMe.md
index bb936737..7364b8e6 100644
--- a/dev/zka/HALKit/AMD64/ReadMe.md
+++ b/dev/zka/HALKit/AMD64/ReadMe.md
@@ -1,4 +1,4 @@
 # AMD64 Hardware Abstraction Layer
 
-- Supported CPU: AMD64 CPU
-- Supported Firmware: EDK 2
+- Supported CPU: AMD64 CPU.
+- Supported Firmware: EDK 2 w/ ZKA's own extensions for EPM.
diff --git a/dev/zka/KernelKit/HardwareThreadScheduler.hxx b/dev/zka/KernelKit/HardwareThreadScheduler.hxx
index 83f6ebd9..3d70e828 100644
--- a/dev/zka/KernelKit/HardwareThreadScheduler.hxx
+++ b/dev/zka/KernelKit/HardwareThreadScheduler.hxx
@@ -14,7 +14,7 @@
 /// @note Last Rev Sun 28 Jul CET 2024
 /// @note Last Rev Thu, Aug  1, 2024  9:07:38 AM
 
-#define cMaxHWThreads (8U)
+#define cMaxHartInsideSched (8U)
 
 namespace Kernel
 {
@@ -37,10 +37,12 @@ namespace Kernel
 	typedef enum ThreadKind ThreadKind;
 	typedef ThreadID		ThreadID;
 
+	/***********************************************************************************/
 	///
 	/// \name HardwareThread
 	/// \brief Abstraction over the CPU's core, used to run processes or threads.
 	///
+	/***********************************************************************************/
 
 	class HardwareThread final
 	{
@@ -131,7 +133,7 @@ namespace Kernel
 		SizeT Count() noexcept;
 
 	private:
-		Array<HardwareThread, cMaxHWThreads> fThreadList;
+		Array<HardwareThread, cMaxHartInsideSched> fThreadList;
 		ThreadID							 fCurrentThread{0};
 	};
 
diff --git a/dev/zka/KernelKit/UserProcessScheduler.hxx b/dev/zka/KernelKit/UserProcessScheduler.hxx
index 3a6f03a1..fc82bf38 100644
--- a/dev/zka/KernelKit/UserProcessScheduler.hxx
+++ b/dev/zka/KernelKit/UserProcessScheduler.hxx
@@ -16,6 +16,9 @@
 #define kSchedInvalidPID		  (-1)
 #define kSchedProcessLimitPerTeam (16U)
 
+#define kSchedMaxMemoryLimit gib_cast(128)
+#define kSchedMaxStackSz mib_cast(8)
+
 ////////////////////////////////////////////////////
 
 // LAST REV: Mon Feb 12 13:52:01 CET 2024
@@ -149,48 +152,48 @@ namespace Kernel
 		ProcessStatusKind  Status{ProcessStatusKind::kDead};
 		UInt8*			   StackReserve{nullptr};
 
-		// Memory, images pointers.
+		//! @brief Code Image.
 		ImagePtr Image{nullptr};
 
-		SizeT StackSize{mib_cast(8)};
+		SizeT StackSize{kSchedMaxStackSz};
 
-		//! @brief Shared library handle, reserved for kDLLKind types of executables only.
-		IPEFDLLObject* DLLPtr{nullptr};
+		//! @brief Shared library handle, reserved for eExecutableDLLKind types of executables only.
+		IPEFDLLObject* PefDLLDelegate{nullptr};
 
 		/// @brief Parent process, reserved for threads only.
 		UserProcess* Parent{nullptr};
 
 		// Memory usage.
 		SizeT MemoryCursor{0};
-		SizeT MemoryLimit{gib_cast(128)};
+		SizeT MemoryLimit{kSchedMaxMemoryLimit};
 
-		struct PROCESS_MEMORY_ENTRY
+		struct PROCESS_MEMORY_ENTRY final
 		{
 			VoidPtr MemoryEntry;
 
 			struct PROCESS_MEMORY_ENTRY* MemoryPrev;
 			struct PROCESS_MEMORY_ENTRY* MemoryNext;
-		}* MemoryEntryList{nullptr};
+		};
+
+		PROCESS_MEMORY_ENTRY* MemoryEntryList{nullptr};
 
 		SizeT MemoryPD{0};
 
 		enum
 		{
-			kExeKind = 1,
-			kDLLKind = 2,
-			kKindCount,
+			eExecutableKind,
+			eExecutableDLLKind,
+			eExecutableKindCount,
 		};
 
-		ProcessTime PTime{0};
+		ProcessTime PTime{0}; //! @brief Process allocated tine.
+
 		PID			ProcessId{kSchedInvalidPID};
-		Int32		Kind{kExeKind};
+		Int32		Kind{eExecutableKind};
 
 	public:
 		//! @brief boolean operator, check status.
-		operator bool()
-		{
-			return Status != ProcessStatusKind::kDead;
-		}
+		operator bool();
 
 		///! @brief Crashes the app, exits with code ~0.
 		Void Crash();
diff --git a/dev/zka/src/CodeMgr.cxx b/dev/zka/src/CodeMgr.cxx
index 13bcd640..cc1d2059 100644
--- a/dev/zka/src/CodeMgr.cxx
+++ b/dev/zka/src/CodeMgr.cxx
@@ -22,7 +22,7 @@ namespace Kernel
 		UserProcess proc;
 		proc.SetImageStart(reinterpret_cast<VoidPtr>(main));
 
-		proc.Kind	   = UserProcess::kExeKind;
+		proc.Kind	   = UserProcess::eExecutableKind;
 		proc.StackSize = kib_cast(32);
 
 		rt_set_memory(proc.Name, 0, kProcessLen);
diff --git a/dev/zka/src/HardwareThreadScheduler.cxx b/dev/zka/src/HardwareThreadScheduler.cxx
index 22a69b9b..ef04907d 100644
--- a/dev/zka/src/HardwareThreadScheduler.cxx
+++ b/dev/zka/src/HardwareThreadScheduler.cxx
@@ -159,7 +159,7 @@ namespace Kernel
 				fThreadList[idx].fKind = kHartBoot;
 			}
 		}
-		else if (idx >= cMaxHWThreads)
+		else if (idx >= cMaxHartInsideSched)
 		{
 			static HardwareThread* fakeThread = nullptr;
 			return {fakeThread};
diff --git a/dev/zka/src/UserProcessScheduler.cxx b/dev/zka/src/UserProcessScheduler.cxx
index 88980f8d..9f0a5a3f 100644
--- a/dev/zka/src/UserProcessScheduler.cxx
+++ b/dev/zka/src/UserProcessScheduler.cxx
@@ -59,6 +59,12 @@ namespace Kernel
 		this->Exit(kErrorProcessFault);
 	}
 
+	//! @brief boolean operator, check status.
+	UserProcess::operator bool()
+	{
+		return this->Status != ProcessStatusKind::kDead;
+	}
+
 	/// @brief Gets the local last exit code.
 	/// @note Not thread-safe.
 	/// @return Int32 the last exit code.
@@ -83,8 +89,9 @@ namespace Kernel
 	}
 
 	/***********************************************************************************/
-
 	/** @brief Add pointer to entry. */
+	/***********************************************************************************/
+
 	VoidPtr UserProcess::New(const SizeT& sz)
 	{
 #ifdef __ZKA_AMD64__
@@ -110,16 +117,19 @@ namespace Kernel
 		}
 		else
 		{
-			auto				  entry		 = this->MemoryEntryList;
+			PROCESS_MEMORY_ENTRY* entry		 = this->MemoryEntryList;
 			PROCESS_MEMORY_ENTRY* prev_entry = nullptr;
 
 			while (!entry)
 			{
+				if (entry->MemoryEntry == nullptr)
+					break; // chose to break here, when we get an already allocated memory entry for our needs.
+
 				prev_entry = entry;
 				entry	   = entry->MemoryNext;
 			}
 
-			entry->MemoryNext			   = new UserProcess::PROCESS_MEMORY_ENTRY();
+			entry->MemoryNext			   = new PROCESS_MEMORY_ENTRY();
 			entry->MemoryNext->MemoryEntry = ptr;
 
 			entry->MemoryNext->MemoryPrev = entry;
@@ -130,13 +140,18 @@ namespace Kernel
 	}
 
 	/***********************************************************************************/
-
 	/** @brief Free pointer from usage. */
+	/***********************************************************************************/
+
 	Boolean UserProcess::Delete(VoidPtr ptr, const SizeT& sz)
 	{
-		auto entry = this->MemoryEntryList;
+		if (!ptr ||
+			sz == 0)
+			return No;
+
+		PROCESS_MEMORY_ENTRY* entry = this->MemoryEntryList;
 
-		while (entry)
+		while (entry != nullptr)
 		{
 			if (entry->MemoryEntry == ptr)
 			{
@@ -149,7 +164,7 @@ namespace Kernel
 
 				return ret;
 #else
-				bool ret = mm_delete_heap(ptr);
+				Bool ret = mm_delete_heap(ptr);
 				return ret;
 #endif
 			}
@@ -157,16 +172,16 @@ namespace Kernel
 			entry = entry->MemoryNext;
 		}
 
-		return false;
+		return No;
 	}
 
-	/// @brief UserProcess name getter.
+	/// @brief Gets the name of the current process..
 	const Char* UserProcess::GetProcessName() noexcept
 	{
 		return this->Name;
 	}
 
-	/// @brief UserProcess user getter.
+	/// @brief Gets the owner of the process.
 	const User* UserProcess::GetOwner() noexcept
 	{
 		return this->Owner;
@@ -179,18 +194,22 @@ namespace Kernel
 	}
 
 	/***********************************************************************************/
-
 	/**
 	@brief Affinity is the time slot allowed for the process.
 	*/
+	/***********************************************************************************/
+
 	const AffinityKind& UserProcess::GetAffinity() noexcept
 	{
 		return this->Affinity;
 	}
 
+	/***********************************************************************************/
 	/**
-	@brief Standard exit proc.
+	@brief Process exit method.
 	*/
+	/***********************************************************************************/
+
 	void UserProcess::Exit(const Int32& exit_code)
 	{
 		this->Status = ProcessStatusKind::kDead;
@@ -208,14 +227,14 @@ namespace Kernel
 		this->Image		 = nullptr;
 		this->StackFrame = nullptr;
 
-		if (this->Kind == kDLLKind)
+		if (this->Kind == eExecutableDLLKind)
 		{
 			Bool success = false;
-			rtl_fini_dll(this, this->DLLPtr, &success);
+			rtl_fini_dll(this, this->PefDLLDelegate, &success);
 
 			if (success)
 			{
-				this->DLLPtr = nullptr;
+				this->PefDLLDelegate = nullptr;
 			}
 		}
 
@@ -251,14 +270,14 @@ namespace Kernel
 		}
 
 		// Create heap according to type of process.
-		if (process.Kind == UserProcess::kDLLKind)
+		if (process.Kind == UserProcess::eExecutableDLLKind)
 		{
-			process.DLLPtr = rtl_init_dll(&process);
+			process.PefDLLDelegate = rtl_init_dll(&process);
 		}
 
 		if (!process.Image)
 		{
-			if (process.Kind != UserProcess::kDLLKind)
+			if (process.Kind != UserProcess::eExecutableDLLKind)
 			{
 				process.Crash();
 				return -kErrorProcessFault;
@@ -398,18 +417,20 @@ namespace Kernel
 			return No;
 
 		if (!process.Image &&
-			process.Kind == UserProcess::kExeKind)
+			process.Kind == UserProcess::eExecutableKind)
 			return No;
 
 		return Yes;
 	}
 
+	/***********************************************************************************/
 	/**
 	 * @brief Scheduler helper class.
 	 */
+	/***********************************************************************************/
 
 	EXTERN
-	HardwareThreadScheduler* cHardwareThreadScheduler;
+	HardwareThreadScheduler* cHardwareThreadScheduler; //! @brief Ask linker for the hardware thread scheduler.
 
 	SizeT UserProcessHelper::StartScheduling()
 	{
@@ -429,11 +450,13 @@ namespace Kernel
 		return ret;
 	}
 
+	/***********************************************************************************/
 	/**
 	 * \brief Does a context switch in a CPU.
 	 * \param the_stack the stackframe of the running app.
 	 * \param new_pid the process's PID.
 	 */
+	/***********************************************************************************/
 
 	Bool UserProcessHelper::Switch(VoidPtr image_ptr, UInt8* stack, HAL::StackFramePtr frame_ptr, const PID& new_pid)
 	{
diff --git a/dev/zka/src/UserThreadScheduler.cxx b/dev/zka/src/UserThreadScheduler.cxx
deleted file mode 100644
index 3fc9aee4..00000000
--- a/dev/zka/src/UserThreadScheduler.cxx
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * ========================================================
- *
- * newoskrnl
- * Copyright ZKA Technologies., all rights reserved.
- *
- *  ========================================================
- */
-
-#include <NewKit/String.hxx>
-#include <CFKit/Property.hxx>
-#include <KernelKit/UserProcessScheduler.hxx>
-
-namespace Kernel
-{
-	/// \brief UserProcess thread information header.
-	struct USER_THREAD_BLOCK final
-	{
-		STATIC constexpr SizeT cMaxLen = 256;
-
-		Char			  fName[cMaxLen] = {"THREAD #0 (PROCESS 0)"};
-		ProcessStatusKind fThreadStatus;
-		Int64			  fThreadID;
-		UserProcessPtr	  fProcess{nullptr};
-		VoidPtr			  fCode{nullptr};
-		VoidPtr			  fStack{nullptr};
-		VoidPtr			  fData{nullptr};
-
-		Void Exit() noexcept
-		{
-			this->fThreadStatus = ProcessStatusKind::kKilled;
-		}
-
-		VoidPtr GetStack() noexcept
-		{
-			return fStack;
-		}
-
-		VoidPtr GetData() noexcept
-		{
-			return fData;
-		}
-
-		VoidPtr GetPC() noexcept
-		{
-			return fCode;
-		}
-	};
-} // namespace Kernel