IMPL: Process scheduler and bit map mgr fixes.

	- Finally got it working, at least before execution, need to fix
	  the VMMgr now.

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

8 files changed, 54 insertions, 78 deletions

diff --git a/dev/Kernel/HALKit/AMD64/HalKernelMain.cc b/dev/Kernel/HALKit/AMD64/HalKernelMain.cc
index aa20c43e..5de6ddd9 100644
--- a/dev/Kernel/HALKit/AMD64/HalKernelMain.cc
+++ b/dev/Kernel/HALKit/AMD64/HalKernelMain.cc
@@ -84,6 +84,7 @@ EXTERN_C void hal_init_platform(
 EXTERN_C Kernel::Void hal_real_init(Kernel::Void) noexcept
 {
 	auto str_proc = Kernel::rt_alloc_string("System");
+
 	Kernel::rtl_create_process(rtl_kernel_main, str_proc);
 
 	delete str_proc;
diff --git a/dev/Kernel/KernelKit/UserProcessScheduler.h b/dev/Kernel/KernelKit/UserProcessScheduler.h
index b79985dd..744ad45a 100644
--- a/dev/Kernel/KernelKit/UserProcessScheduler.h
+++ b/dev/Kernel/KernelKit/UserProcessScheduler.h
@@ -154,7 +154,7 @@ namespace Kernel
 		ZKA_COPY_DEFAULT(UserProcess);
 
 	public:
-		Char			   Name[kProcessNameLen] = {"Process (Unnamed, No Subsystem)"};
+		Char			   Name[kProcessNameLen] = {"Process"};
 		ProcessSubsystem   SubSystem{ProcessSubsystem::kProcessSubsystemInvalid};
 		User*			   Owner{nullptr};
 		HAL::StackFramePtr StackFrame{nullptr};
diff --git a/dev/Kernel/src/BitMapMgr.cc b/dev/Kernel/src/BitMapMgr.cc
index 7f289073..aa32cb93 100644
--- a/dev/Kernel/src/BitMapMgr.cc
+++ b/dev/Kernel/src/BitMapMgr.cc
@@ -82,9 +82,12 @@ namespace Kernel
 				/// @return The new address which was found.
 				auto FindBitMap(VoidPtr base_ptr, SizeT size, Bool wr, Bool user) -> VoidPtr
 				{
+					if (!size)
+						return nullptr;
+
 					VoidPtr base = reinterpret_cast<VoidPtr>(((UIntPtr)base_ptr) + kPageSize);
 
-					while (base && size)
+					while (((UIntPtr)base) < (reinterpret_cast<UIntPtr>(base) + kHandoverHeader->f_BitMapSize))
 					{
 						UIntPtr* ptr_bit_set = reinterpret_cast<UIntPtr*>(base);
 
@@ -106,8 +109,6 @@ namespace Kernel
 						}
 						else if (ptr_bit_set[kBitMapMagIdx] != kBitMapMagic)
 						{
-							UIntPtr* ptr_bit_set = reinterpret_cast<UIntPtr*>(base_ptr);
-
 							ptr_bit_set[kBitMapMagIdx]	= kBitMapMagic;
 							ptr_bit_set[kBitMapSizeIdx] = size;
 							ptr_bit_set[kBitMapUsedIdx] = Yes;
@@ -120,10 +121,7 @@ namespace Kernel
 							return (VoidPtr)ptr_bit_set;
 						}
 
-						base = reinterpret_cast<VoidPtr>(reinterpret_cast<UIntPtr>(base_ptr) + (ptr_bit_set[0] != kBitMapMagic ? size : ptr_bit_set[1]));
-
-						if ((UIntPtr)base_ptr < (reinterpret_cast<UIntPtr>(base) + kHandoverHeader->f_BitMapSize))
-							return nullptr;
+						base = reinterpret_cast<VoidPtr>(reinterpret_cast<UIntPtr>(base) + ((ptr_bit_set[kBitMapMagIdx] != kBitMapMagic) ? size : ptr_bit_set[kBitMapSizeIdx]));
 					}
 
 					return nullptr;
@@ -145,7 +143,7 @@ namespace Kernel
 					kcout << "Size of BitMap (MIB): " << number(MIB(ptr_bit_set[kBitMapSizeIdx])) << endl;
 					kcout << "Size of BitMap (GIB): " << number(GIB(ptr_bit_set[kBitMapSizeIdx])) << endl;
 					kcout << "Size of BitMap (TIB): " << number(TIB(ptr_bit_set[kBitMapSizeIdx])) << endl;
-					kcout << "Address Of BitMap: " << hex_number((UIntPtr)ptr_bit_set) << endl;
+					kcout << "Address Of BitMap Header: " << hex_number((UIntPtr)ptr_bit_set) << endl;
 				}
 			};
 		} // namespace Detail
diff --git a/dev/Kernel/src/CodeMgr.cc b/dev/Kernel/src/CodeMgr.cc
index 53576b2c..ccf0659b 100644
--- a/dev/Kernel/src/CodeMgr.cc
+++ b/dev/Kernel/src/CodeMgr.cc
@@ -34,8 +34,8 @@ namespace Kernel
 
 		ProcessID id = UserProcessScheduler::The().Spawn(process_hdr);
 
-		if (id == kProcessInvalidID)
-			delete process_hdr;
+		delete process_hdr;
+		process_hdr = nullptr;
 
 		return id;
 	}
diff --git a/dev/Kernel/src/Heap.cc b/dev/Kernel/src/Heap.cc
index 3f3d05c5..6f955078 100644
--- a/dev/Kernel/src/Heap.cc
+++ b/dev/Kernel/src/Heap.cc
@@ -136,7 +136,7 @@ namespace Kernel
 
 		heap_info_ptr->fHeapSize  = sz_fix;
 		heap_info_ptr->fMagic	  = kKernelHeapMagic;
-		heap_info_ptr->fCRC32	  = No; // dont fill it for now.
+		heap_info_ptr->fCRC32	  = 0; // dont fill it for now.
 		heap_info_ptr->fHeapPtr	  = reinterpret_cast<UIntPtr>(heap_info_ptr) + sizeof(Detail::HEAP_INFORMATION_BLOCK);
 		heap_info_ptr->fPagePtr	  = No;
 		heap_info_ptr->fWriteRead = wr;
@@ -227,19 +227,6 @@ namespace Kernel
 				return kErrorHeapNotPresent;
 			}
 
-			if (heap_info_ptr->fCRC32 != 0)
-			{
-				if (heap_info_ptr->fCRC32 !=
-					ke_calculate_crc32((Char*)heap_info_ptr->fHeapPtr,
-									   heap_info_ptr->fHeapSize))
-				{
-					if (!heap_info_ptr->fUser)
-					{
-						ke_panic(RUNTIME_CHECK_POINTER);
-					}
-				}
-			}
-
 			heap_info_ptr->fHeapSize  = 0UL;
 			heap_info_ptr->fPresent	  = No;
 			heap_info_ptr->fHeapPtr	  = 0;
@@ -275,6 +262,13 @@ namespace Kernel
 
 			if (heap_info_ptr && heap_info_ptr->fPresent && heap_info_ptr->fMagic == kKernelHeapMagic)
 			{
+				if (heap_info_ptr->fCRC32 !=
+					ke_calculate_crc32((Char*)heap_info_ptr->fHeapPtr,
+									   heap_info_ptr->fHeapSize))
+				{
+					return No;
+				}
+
 				return Yes;
 			}
 		}
diff --git a/dev/Kernel/src/KernelPanic.cc b/dev/Kernel/src/KernelPanic.cc
index f5782ebf..d0119b5e 100644
--- a/dev/Kernel/src/KernelPanic.cc
+++ b/dev/Kernel/src/KernelPanic.cc
@@ -62,7 +62,7 @@ namespace Kernel
 			break;
 		}
 		case RUNTIME_CHECK_POINTER: {
-			fb_render_string("0x00000000: Kernel heap is corrupted.", start_y, x, panic_text);
+			fb_render_string("0x00000000: Pointer is invalid.", start_y, x, panic_text);
 			break;
 		}
 		case RUNTIME_CHECK_BAD_BEHAVIOR: {
diff --git a/dev/Kernel/src/UserProcessScheduler.cc b/dev/Kernel/src/UserProcessScheduler.cc
index b00779e9..831acf42 100644
--- a/dev/Kernel/src/UserProcessScheduler.cc
+++ b/dev/Kernel/src/UserProcessScheduler.cc
@@ -12,6 +12,7 @@
 /// @brief Low level/Ring-3 process scheduler.
 /***********************************************************************************/
 
+#include "HALKit/AMD64/Processor.h"
 #include <KernelKit/UserProcessScheduler.h>
 #include <KernelKit/HardwareThreadScheduler.h>
 #include <KernelKit/IPEFDLLObject.h>
@@ -281,46 +282,46 @@ namespace Kernel
 
 	ProcessID UserProcessScheduler::Spawn(UserProcess* process)
 	{
-		if (!process ||
-			!process->Image.HasCode())
-		{
-			return kProcessInvalidID;
-		}
-
 #ifdef __ZKA_AMD64__
-		process->VMRegister = mm_new_heap(sizeof(PDE), No, Yes);
+		process->VMRegister = new PDE();
 
 		if (!process->VMRegister)
 		{
 			process->Crash();
-			return -kErrorProcessFault;
+			return kErrorProcessFault;
 		}
-#endif // __ZKA_AMD64__
 
-		kcout << "Create VMRegister for: " << process->Name << endl;
+		UInt32 flags = HAL::kMMFlagsPresent;
+		flags |= HAL::kMMFlagsWr;
+		flags |= HAL::kMMFlagsUser;
+
+		HAL::mm_map_page((VoidPtr)process->VMRegister, flags);
+#endif // __ZKA_AMD64__
 
-		process->StackFrame = reinterpret_cast<HAL::StackFramePtr>(mm_new_heap(sizeof(HAL::StackFrame), Yes, Yes));
+		process->StackFrame = new HAL::StackFrame();
 
 		if (!process->StackFrame)
 		{
 			process->Crash();
-			return -kErrorProcessFault;
+			return kErrorProcessFault;
 		}
 
-		kcout << "Create StackFrame for: " << process->Name << endl;
+		flags = HAL::kMMFlagsPresent;
+		flags |= HAL::kMMFlagsWr;
+		flags |= HAL::kMMFlagsUser;
+
+		HAL::mm_map_page((VoidPtr)process->StackFrame, flags);
 
-		// Create heap according to type of process->
+		// Create heap according to type of process.
 		if (process->Kind == UserProcess::kExectuableDLLKind)
 		{
 			process->DylibDelegate = rtl_init_dylib(process);
 			MUST_PASS(process->DylibDelegate);
-
-			kcout << "Created DylibDelegate for process: " << process->Name << endl;
 		}
 
 		process->StackReserve = new UInt8[process->StackSize];
 
-		UInt32 flags = HAL::kMMFlagsPresent;
+		flags = HAL::kMMFlagsPresent;
 		flags |= HAL::kMMFlagsWr;
 		flags |= HAL::kMMFlagsUser;
 
@@ -332,12 +333,14 @@ namespace Kernel
 			return -kErrorProcessFault;
 		}
 
-		kcout << "Created StackReserve for process: " << process->Name << endl;
-
 		ProcessID pid = this->mTeam.mProcessCount;
 
-		if (pid > kSchedProcessLimitPerTeam)
-			return kProcessInvalidID;
+		if (pid > kSchedProcessLimitPerTeam &&
+			pid != (kSchedProcessLimitPerTeam + 1))
+		{
+			this->mTeam.mProcessCount = 0;
+			pid = 0UL;
+		}
 
 		++this->mTeam.mProcessCount;
 
@@ -347,11 +350,10 @@ namespace Kernel
 		process->Status	   = ProcessStatusKind::kStarting;
 		process->PTime	   = (UIntPtr)AffinityKind::kStandard;
 
-		kcout << "Process Name: " << process->Name << endl;
-		kcout << "PID: " << number(process->ProcessId) << endl;
-
 		this->mTeam.mProcessList.Assign(pid, process);
 
+		kcout << "PID: " << number(process->ProcessId) << endl;
+
 		return process->ProcessId;
 	}
 
@@ -412,7 +414,7 @@ namespace Kernel
 		SizeT process_index = 0; //! we store this guy to tell the scheduler how many
 								 //! things we have scheduled.
 
-		if (mTeam.mProcessList.Empty())
+		if (mTeam.mProcessCount < 1)
 		{
 			kcout << "UserProcessScheduler::Run(): This team doesn't have any process!\r";
 			return 0;
diff --git a/dev/Kernel/src/Utils.cc b/dev/Kernel/src/Utils.cc
index 448e17b7..9f4a8609 100644
--- a/dev/Kernel/src/Utils.cc
+++ b/dev/Kernel/src/Utils.cc
@@ -10,10 +10,6 @@ namespace Kernel
 {
 	Int32 rt_string_cmp(const Char* src, const Char* cmp, Size size)
 	{
-		if (!cmp ||
-			!src)
-			return 1;
-
 		Int32 counter = 0;
 
 		for (Size index = 0; index < size; ++index)
@@ -51,19 +47,14 @@ namespace Kernel
 	{
 		SizeT cnt{0};
 
-		do
-		{
+		while (ptr[cnt] != 0)
 			++cnt;
-		} while (ptr[cnt] != 0);
 
 		return cnt;
 	}
 
 	voidPtr rt_set_memory(voidPtr src, UInt32 value, Size len)
 	{
-		if (!src || len < 1)
-			return nullptr;
-
 		UInt32* start = reinterpret_cast<UInt32*>(src);
 
 		while (len)
@@ -78,12 +69,6 @@ namespace Kernel
 
 	Int rt_move_memory(const voidPtr src, voidPtr dst, Size len)
 	{
-		if (len < 1)
-			return 2;
-
-		if (!src || !dst)
-			return 1;
-
 		Char* srcChr  = reinterpret_cast<Char*>(src);
 		Char* dstChar = reinterpret_cast<Char*>(dst);
 		SizeT index	  = 0;
@@ -101,9 +86,6 @@ namespace Kernel
 
 	Int rt_copy_memory(const voidPtr src, voidPtr dst, Size len)
 	{
-		if (len < 1)
-			return 0;
-
 		char* srcChr  = reinterpret_cast<char*>(src);
 		char* dstChar = reinterpret_cast<char*>(dst);
 		Size  index	  = 0;
@@ -114,23 +96,22 @@ namespace Kernel
 			++index;
 		}
 
+		dstChar[index] = 0;
+
 		return index;
 	}
 
-	const Char* rt_alloc_string(const Char* text)
+	const Char* rt_alloc_string(const Char* src)
 	{
-		if (!text[0])
-			return nullptr;
-
-		const Char* string = new Char[rt_string_len(text)];
+		const Char* string = new Char[rt_string_len(src) + 1];
 
 		if (!string)
 			return nullptr;
 
-		voidPtr vText = reinterpret_cast<voidPtr>(const_cast<char*>(text));
-		voidPtr vStr  = reinterpret_cast<voidPtr>(const_cast<char*>(string));
+		voidPtr v_src = reinterpret_cast<voidPtr>(const_cast<char*>(src));
+		voidPtr v_dst  = reinterpret_cast<voidPtr>(const_cast<char*>(string));
 
-		rt_copy_memory(vText, vStr, rt_string_len(text));
+		rt_copy_memory(v_src, v_dst, rt_string_len(src) + 1);
 
 		return string;
 	}