IMP: Scheduler improvements, fixing stack issue of kernel now.

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

9 files changed, 104 insertions, 87 deletions

diff --git a/dev/ZKAKit/src/CodeMgr.cc b/dev/ZKAKit/src/CodeMgr.cc
index 4031736a..335d1d87 100644
--- a/dev/ZKAKit/src/CodeMgr.cc
+++ b/dev/ZKAKit/src/CodeMgr.cc
@@ -23,15 +23,15 @@ namespace Kernel
 
 		UserProcess* proc = new UserProcess{reinterpret_cast<VoidPtr>(main)};
 
-		kcout << "Setting-up process...\r";
+		kcout << "Setting-up process data...\r";
 
 		proc->Kind		= UserProcess::kExectuableKind;
-		proc->StackSize = kib_cast(8);
-		proc->PTime		= 0UL;
+		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));
 
-		ProcessID id = UserProcessScheduler::The().Add(*proc);
+		ProcessID id = UserProcessScheduler::The().Add(proc);
 
 		delete proc;
 
diff --git a/dev/ZKAKit/src/DriveMgr.cc b/dev/ZKAKit/src/DriveMgr.cc
index 3d11600b..812bec36 100644
--- a/dev/ZKAKit/src/DriveMgr.cc
+++ b/dev/ZKAKit/src/DriveMgr.cc
@@ -158,10 +158,12 @@ namespace Kernel
 			if (rt_string_cmp(block_struct.Magic, kEPMMagic, kEPMMagicLength) == 0)
 			{
 				trait.fKind |= kEPMDrive;
+				kcout << "Formatted drive is EPM.\r";
 			}
 			else
 			{
 				trait.fKind |= kUnformattedDrive;
+				kcout << "Formatted drive is blank.\r";
 			}
 
 			trait.fPacket.fLba			 = 0;
@@ -178,14 +180,14 @@ namespace Kernel
 
 		rt_copy_memory((VoidPtr) "/Mount/OS:", trait.fName, rt_string_len("/Mount/OS:"));
 
-		Detail::ioi_detect_drive(trait);
-
 		trait.fVerify	 = io_drv_unimplemented;
 		trait.fOutput	 = io_drv_output;
 		trait.fInput	 = io_drv_input;
 		trait.fInit		 = io_drv_init;
 		trait.fDriveKind = io_drv_kind;
 
+		Detail::ioi_detect_drive(trait);
+
 		kcout << "Construct: " << trait.fName << ".\r";
 
 		return trait;
diff --git a/dev/ZKAKit/src/FS/NeFS.cc b/dev/ZKAKit/src/FS/NeFS.cc
index bd93332a..53c88aa0 100644
--- a/dev/ZKAKit/src/FS/NeFS.cc
+++ b/dev/ZKAKit/src/FS/NeFS.cc
@@ -501,18 +501,18 @@ bool NeFSParser::Format(_Input _Output DriveTrait* drive, _Input const Lba endLb
 
 		BOOT_BLOCK_STRUCT* epmBoot = (BOOT_BLOCK_STRUCT*)bufEpmHdr;
 
-		// EPM header.
+		// Write a new EPM entry.
 
-		constexpr auto cFsName	  = "NeFS";
-		constexpr auto cBlockName = "ZKA:";
+		constexpr auto kFsName	  = "NeFS";
+		constexpr auto kBlockName = "ZKA:";
 
-		rt_copy_memory(reinterpret_cast<VoidPtr>(const_cast<Char*>(cFsName)), epmBoot->Fs, rt_string_len(cFsName));
+		rt_copy_memory(reinterpret_cast<VoidPtr>(const_cast<Char*>(kFsName)), epmBoot->Fs, rt_string_len(kFsName));
 
 		epmBoot->FsVersion = kNeFSVersionInteger;
 		epmBoot->LbaStart  = start;
 		epmBoot->SectorSz  = kNeFSSectorSz;
 
-		rt_copy_memory(reinterpret_cast<VoidPtr>(const_cast<Char*>(cBlockName)), epmBoot->Name, rt_string_len(cBlockName));
+		rt_copy_memory(reinterpret_cast<VoidPtr>(const_cast<Char*>(kBlockName)), epmBoot->Name, rt_string_len(kBlockName));
 		rt_copy_memory(reinterpret_cast<VoidPtr>(const_cast<Char*>(kEPMMagic)), epmBoot->Magic, rt_string_len(kEPMMagic));
 
 		Lba outEpmLba = kEPMBaseLba;
diff --git a/dev/ZKAKit/src/Heap.cc b/dev/ZKAKit/src/Heap.cc
index fc3f7051..9d36d04e 100644
--- a/dev/ZKAKit/src/Heap.cc
+++ b/dev/ZKAKit/src/Heap.cc
@@ -22,8 +22,9 @@
 //! @file Heap.cc
 //! @brief The Kernel's heap manager serves as the main memory manager.
 
-#define kKernelHeapMagic (0xD4D7D5)
-#define kKernelAlignSz	 (__BIGGEST_ALIGNMENT__)
+#define kKernelHeapMagic   (0xD4D7D5)
+#define kKernelHeapAlignSz (__BIGGEST_ALIGNMENT__)
+#define kKernelHeapMaxSize (gib_cast(2))
 
 namespace Kernel
 {
@@ -65,7 +66,7 @@ namespace Kernel
 			UIntPtr fHeapPtr;
 
 			/// @brief Padding bytes for header.
-			UInt8 fPadding[kKernelAlignSz];
+			UInt8 fPadding[kKernelHeapAlignSz];
 		};
 
 		/// @brief Check for heap address validity.
@@ -121,7 +122,7 @@ namespace Kernel
 			return nullptr;
 
 		// We can't allocate that big now.
-		MUST_PASS(sz <= gib_cast(2));
+		MUST_PASS(sz < kKernelHeapMaxSize);
 
 		sz_fix += sizeof(Detail::HEAP_INFORMATION_BLOCK);
 
@@ -141,7 +142,7 @@ namespace Kernel
 		heap_info_ptr->fUser	 = user;
 		heap_info_ptr->fPresent	 = Yes;
 
-		rt_set_memory(heap_info_ptr->fPadding, 0, kKernelAlignSz);
+		rt_set_memory(heap_info_ptr->fPadding, 0, kKernelHeapAlignSz);
 
 		auto result = reinterpret_cast<VoidPtr>(heap_info_ptr->fHeapPtr);
 
diff --git a/dev/ZKAKit/src/IPEFDLLObject.cc b/dev/ZKAKit/src/IPEFDLLObject.cc
index c68f582d..620002d8 100644
--- a/dev/ZKAKit/src/IPEFDLLObject.cc
+++ b/dev/ZKAKit/src/IPEFDLLObject.cc
@@ -60,7 +60,7 @@ EXTERN_C IDLL rtl_init_dll(UserProcess* header)
 	}
 
 	dll_obj->Get()->fImageObject =
-		header->Image;
+		header->ExecImg;
 
 	if (!dll_obj->Get()->fImageObject)
 	{
diff --git a/dev/ZKAKit/src/PEFCodeMgr.cc b/dev/ZKAKit/src/PEFCodeMgr.cc
index a2b3482a..ba0d3a78 100644
--- a/dev/ZKAKit/src/PEFCodeMgr.cc
+++ b/dev/ZKAKit/src/PEFCodeMgr.cc
@@ -226,6 +226,11 @@ namespace Kernel
 		return kPefApplicationMime;
 	}
 
+	ErrorOr<VoidPtr> PEFLoader::GetBlob()
+	{
+		return ErrorOr<VoidPtr>{this->fCachedBlob};
+	}
+
 	namespace Utils
 	{
 		ProcessID rtl_create_process(PEFLoader& exec, const Int32& procKind) noexcept
@@ -238,11 +243,12 @@ namespace Kernel
 			UserProcess* proc = new UserProcess{errOrStart.Leak().Leak()};
 
 			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;
 
-			rt_set_memory(proc->Name, 0, kProcessLen);
+			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)));
@@ -253,7 +259,7 @@ namespace Kernel
 				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/Stop.cc b/dev/ZKAKit/src/Stop.cc
index 122b4489..c244456a 100644
--- a/dev/ZKAKit/src/Stop.cc
+++ b/dev/ZKAKit/src/Stop.cc
@@ -21,7 +21,7 @@
 
 namespace Kernel
 {
-	Void ke_stop(const Kernel::Int& id)
+	Void ke_stop(const Kernel::Int32& id)
 	{
 		CGInit();
 
@@ -30,7 +30,7 @@ namespace Kernel
 		auto start_y = 10;
 		auto x		 = 10;
 
-		CGDrawString("minoskrnl.exe stopped working properly so it had to stop.", start_y, x, panic_text);
+		CGDrawString("minoskrnl.exe, bug check error raised, stopping...", start_y, x, panic_text);
 		start_y += 10;
 
 		// simply offset from previous string and then write the website.
diff --git a/dev/ZKAKit/src/UserProcessScheduler.cc b/dev/ZKAKit/src/UserProcessScheduler.cc
index 67eac095..96d2244f 100644
--- a/dev/ZKAKit/src/UserProcessScheduler.cc
+++ b/dev/ZKAKit/src/UserProcessScheduler.cc
@@ -35,13 +35,19 @@ namespace Kernel
 	UInt32 kLastExitCode = 0U;
 
 	/***********************************************************************************/
+	/// @brief Process count global variable.
+	/***********************************************************************************/
+
+	ProcessID kProcessIDCounter = 0UL;
+
+	/***********************************************************************************/
 	/// @brief User Process scheduler global and external reference of thread scheduler.
 	/***********************************************************************************/
 
 	UserProcessScheduler kProcessScheduler;
 
 	UserProcess::UserProcess(VoidPtr start_image)
-		: Image(start_image)
+		: Code(start_image)
 	{
 	}
 
@@ -71,7 +77,7 @@ namespace Kernel
 
 	UserProcess::operator bool()
 	{
-		return this->Status == ProcessStatusKind::kRunning && this->Image != nullptr;
+		return this->Status == ProcessStatusKind::kRunning;
 	}
 
 	/***********************************************************************************/
@@ -239,7 +245,10 @@ namespace Kernel
 
 	void UserProcess::Exit(const Int32& exit_code)
 	{
-		this->Status = ProcessStatusKind::kDead;
+		if (exit_code > 0)
+			this->Status = ProcessStatusKind::kKilled;
+		else
+			this->Status = ProcessStatusKind::kDead;
 
 		fLastExitCode = exit_code;
 		kLastExitCode = exit_code;
@@ -275,13 +284,13 @@ namespace Kernel
 		HAL::mm_free_bitmap(reinterpret_cast<VoidPtr>(this->VMRegister));
 
 		//! Delete image if not done already.
-		if (this->Image && mm_is_valid_heap(this->Image))
-			mm_delete_heap(this->Image);
+		if (this->Code && mm_is_valid_heap(this->Code))
+			mm_delete_heap(this->Code);
 
 		if (this->StackFrame && mm_is_valid_heap(this->StackFrame))
 			mm_delete_heap((VoidPtr)this->StackFrame);
 
-		this->Image		 = nullptr;
+		this->Code		 = nullptr;
 		this->StackFrame = nullptr;
 
 		if (this->Kind == kExectuableDLLKind)
@@ -310,71 +319,61 @@ namespace Kernel
 	/// @return the process index inside the team.
 	/***********************************************************************************/
 
-	SizeT UserProcessScheduler::Add(UserProcess process)
+	ProcessID UserProcessScheduler::Add(UserProcess* process)
 	{
-		kcout << "Creating process: " << process.Name << ", prevous process count: " << number(mTeam.mProcessList.Count()) << endl;
-
-		if (mTeam.mProcessList.Count() >= kSchedProcessLimitPerTeam)
-			return kErrorInvalidData;
-
-		kcout << "Create vm_register of: " << process.Name << endl;
+		kcout << "Create VMRegister of: " << process->Name << endl;
 
 #ifdef __ZKA_AMD64__
-		process.VMRegister = reinterpret_cast<UIntPtr>(mm_new_heap(sizeof(PDE), No, Yes));
+		process->VMRegister = reinterpret_cast<UIntPtr>(mm_new_heap(sizeof(PDE), No, Yes));
 
-		if (!process.VMRegister)
+		if (!process->VMRegister)
 		{
-			process.Crash();
-			return kErrorProcessFault;
+			process->Crash();
+			return -kErrorProcessFault;
 		}
 #endif // __ZKA_AMD64__
 
-		kcout << "Create stack_frame of: " << process.Name << endl;
+		kcout << "Create StackFrame of: " << process->Name << endl;
 
-		process.StackFrame = reinterpret_cast<HAL::StackFramePtr>(mm_new_heap(sizeof(HAL::StackFrame), Yes, Yes));
+		process->StackFrame = reinterpret_cast<HAL::StackFramePtr>(mm_new_heap(sizeof(HAL::StackFrame), Yes, Yes));
 
-		if (!process.StackFrame)
+		if (!process->StackFrame)
 		{
-			process.Crash();
-			return kErrorProcessFault;
+			process->Crash();
+			return -kErrorProcessFault;
 		}
 
-		kcout << "Create delegate if DLL for: " << process.Name << endl;
-
-		// Create heap according to type of process.
-		if (process.Kind == UserProcess::kExectuableDLLKind)
+		// Create heap according to type of process->
+		if (process->Kind == UserProcess::kExectuableDLLKind)
 		{
-			process.PefDLLDelegate = rtl_init_dll(&process);
+			kcout << "Create delegate dylib for: " << process->Name << endl;
+			process->PefDLLDelegate = rtl_init_dll(process);
 		}
 
-		kcout << "Validate image of: " << process.Name << endl;
+		process->StackReserve = reinterpret_cast<UInt8*>(mm_new_heap(sizeof(UInt8) * process->StackSize, Yes, Yes));
+
+		kcout << "Validate stack reserve: " << number((UIntPtr)process->StackReserve) << endl;
 
-		if (!process.Image)
+		if (!process->StackReserve)
 		{
-			process.Crash();
-			return kErrorProcessFault;
+			process->Crash();
+			return -kErrorProcessFault;
 		}
 
-		kcout << "Validate stack reserve of: " << process.Name << endl;
+		auto pid = 0UL;
 
-		// Get preferred stack size by app.
-		const auto kMaxStackSize = process.StackSize;
-		process.StackReserve	 = reinterpret_cast<UInt8*>(mm_new_heap(sizeof(UInt8) * kMaxStackSize, Yes, Yes));
-
-		if (!process.StackReserve)
-		{
-			process.Crash();
-			return kErrorProcessFault;
-		}
+		process->ProcessId = pid;
+		process->Status	   = ProcessStatusKind::kRunning;
+		process->PTime	   = (UIntPtr)AffinityKind::kStandard;
 
-		process.ProcessId = 0UL;
-		process.Status	  = ProcessStatusKind::kRunning;
+		mTeam.AsArray().Assign(pid, *process);
 
-		mTeam.AsArray()[process.ProcessId] = process;
+		kcout << "Process Name: " << mTeam.AsArray()[pid].Name << endl;
+		kcout << "PID: " << number(mTeam.AsArray()[pid].ProcessId) << endl;
 
-		kcout << "Create process: " << process.Name << endl;
+		BREAK_POINT();
 
-		return process.ProcessId;
+		return pid;
 	}
 
 	/***********************************************************************************/
@@ -402,7 +401,7 @@ namespace Kernel
 		if (process_id > mTeam.mProcessList.Count())
 			return No;
 
-		mTeam.AsArray()[process_id].Status = ProcessStatusKind::kDead;
+		--kProcessIDCounter;
 
 		return Yes;
 	}
@@ -445,24 +444,23 @@ namespace Kernel
 
 		for (; process_index < mTeam.AsArray().Capacity(); ++process_index)
 		{
-			auto& process = mTeam.AsArray()[process_index];
+			auto process = mTeam.AsArray()[process_index];
 
 			//! check if process needs to be scheduled.
 			if (UserProcessHelper::CanBeScheduled(process))
 			{
+				// Set current process header.
+				this->GetCurrentProcess() = process;
+
 				process.PTime = static_cast<Int32>(process.Affinity);
 
 				kcout << "Switch to '" << process.Name << "'.\r";
 
-				// Set current process header.
-				this->GetCurrentProcess() = process;
-
 				// tell helper to find a core to schedule on.
-				if (!UserProcessHelper::Switch(process.Image, &process.StackReserve[process.StackSize - 1], process.StackFrame,
+				if (!UserProcessHelper::Switch(process.Code, &process.StackReserve[process.StackSize - 1], process.StackFrame,
 											   process.ProcessId))
 				{
 					process.Crash();
-					continue;
 				}
 			}
 			else
@@ -492,10 +490,13 @@ namespace Kernel
 
 	/// @brief Current proccess id getter.
 	/// @return UserProcess ID integer.
-	PID& UserProcessHelper::TheCurrentPID()
+	ErrorOr<PID> UserProcessHelper::TheCurrentPID()
 	{
+		if (!kProcessScheduler.GetCurrentProcess())
+			return ErrorOr<PID>{kErrorProcessFault};
+
 		kcout << "UserProcessHelper::TheCurrentPID: Leaking ProcessId...\r";
-		return kProcessScheduler.GetCurrentProcess().Leak().ProcessId;
+		return ErrorOr<PID>{kProcessScheduler.GetCurrentProcess().Leak().ProcessId};
 	}
 
 	/// @brief Check if process can be schedulded.
@@ -505,13 +506,17 @@ namespace Kernel
 	Bool UserProcessHelper::CanBeScheduled(const UserProcess& process)
 	{
 		if (process.Status == ProcessStatusKind::kKilled ||
-			process.Status == ProcessStatusKind::kDead)
+			process.Status == ProcessStatusKind::kDead ||
+			process.Status == ProcessStatusKind::kFrozen)
+			return No;
+
+		if (process.Status == ProcessStatusKind::kInvalid)
 			return No;
 
-		if (!process.Image)
+		if (!process.Code)
 			return No;
 
-		return process.PTime < 1 && process.Status == ProcessStatusKind::kRunning;
+		return process.PTime < 1;
 	}
 
 	/***********************************************************************************/
@@ -537,6 +542,9 @@ namespace Kernel
 		if (!stack || !frame_ptr || !image_ptr || new_pid < 0)
 			return No;
 
+		if (!mm_is_valid_heap(image_ptr))
+			return No;
+
 		for (SizeT index = 0UL; index < HardwareThreadScheduler::The().Count(); ++index)
 		{
 			if (HardwareThreadScheduler::The()[index].Leak()->Kind() == kInvalidHart)
@@ -547,8 +555,8 @@ namespace Kernel
 				HardwareThreadScheduler::The()[index].Leak()->Kind() !=
 					ThreadKind::kHartSystemReserved)
 			{
-				PID prev_pid					   = UserProcessHelper::TheCurrentPID();
-				UserProcessHelper::TheCurrentPID() = new_pid;
+				PID prev_pid									 = UserProcessHelper::TheCurrentPID();
+				UserProcessHelper::TheCurrentPID().Leak().Leak() = new_pid;
 
 				////////////////////////////////////////////////////////////
 				///	Prepare task switch.								 ///
@@ -565,7 +573,7 @@ namespace Kernel
 				if (!ret)
 				{
 					HardwareThreadScheduler::The()[index].Leak()->fPTime = prev_ptime;
-					UserProcessHelper::TheCurrentPID()					 = prev_pid;
+					UserProcessHelper::TheCurrentPID().Leak().Leak()	 = prev_pid;
 
 					continue;
 				}
diff --git a/dev/ZKAKit/src/Utils.cc b/dev/ZKAKit/src/Utils.cc
index f6564f38..9a2b5e78 100644
--- a/dev/ZKAKit/src/Utils.cc
+++ b/dev/ZKAKit/src/Utils.cc
@@ -34,7 +34,7 @@ namespace Kernel
 	{
 		SizeT len{0};
 
-		while (str[len] != '\0')
+		do
 		{
 			if (len > _len)
 			{
@@ -42,7 +42,7 @@ namespace Kernel
 			}
 
 			++len;
-		}
+		} while (str[len] != '\0');
 
 		return len;
 	}
@@ -51,10 +51,10 @@ namespace Kernel
 	{
 		SizeT cnt{0};
 
-		while (ptr[cnt] != 0)
+		do
 		{
 			++cnt;
-		}
+		} while (ptr[cnt] != 0);
 
 		return cnt;
 	}
@@ -211,7 +211,7 @@ namespace Kernel
 	}
 } // namespace Kernel
 
-EXTERN_C void* memset(void* dst, char c, Kernel::Size len)
+EXTERN_C Kernel::VoidPtr memset(Kernel::VoidPtr dst, Kernel::UInt32 c, Kernel::Size len)
 {
 	return Kernel::rt_set_memory(dst, c, len);
 }