FIX: User Scheduler, fix process creation.

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

8 files changed, 87 insertions, 59 deletions

diff --git a/dev/ZKAKit/src/CodeMgr.cc b/dev/ZKAKit/src/CodeMgr.cc
index b71f49d3..4031736a 100644
--- a/dev/ZKAKit/src/CodeMgr.cc
+++ b/dev/ZKAKit/src/CodeMgr.cc
@@ -16,18 +16,25 @@ 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";
+
 		if (!main)
 			return No;
 
-		UserProcess proc;
+		UserProcess* proc = new UserProcess{reinterpret_cast<VoidPtr>(main)};
+
+		kcout << "Setting-up process...\r";
+
+		proc->Kind		= UserProcess::kExectuableKind;
+		proc->StackSize = kib_cast(8);
+		proc->PTime		= 0UL;
+
+		rt_copy_memory((VoidPtr)process_name, proc->Name, rt_string_len(process_name));
 
-		proc.Image	   = reinterpret_cast<VoidPtr>(main);
-		proc.Kind	   = UserProcess::kExectuableKind;
-		proc.StackSize = kib_cast(32);
+		ProcessID id = UserProcessScheduler::The().Add(*proc);
 
-		rt_set_memory(proc.Name, 0, kProcessLen);
-		rt_copy_memory((VoidPtr)process_name, proc.Name, rt_string_len(process_name));
+		delete proc;
 
-		return UserProcessScheduler::The().Add(proc);
+		return id;
 	}
 } // namespace Kernel
diff --git a/dev/ZKAKit/src/FS/NeFS.cc b/dev/ZKAKit/src/FS/NeFS.cc
index 652f41e3..bd93332a 100644
--- a/dev/ZKAKit/src/FS/NeFS.cc
+++ b/dev/ZKAKit/src/FS/NeFS.cc
@@ -61,7 +61,7 @@ STATIC MountpointInterface kDiskMountpoint;
 /// @return the fork
 /***********************************************************************************/
 _Output NFS_FORK_STRUCT* NeFSParser::CreateFork(_Input NFS_CATALOG_STRUCT* catalog,
-												_Input NFS_FORK_STRUCT&	   the_fork)
+												_Input NFS_FORK_STRUCT& the_fork)
 {
 	if (catalog && the_fork.ForkName[0] != 0 &&
 		the_fork.DataSize <= kNeFSForkDataSz)
@@ -170,8 +170,8 @@ _Output NFS_FORK_STRUCT* NeFSParser::CreateFork(_Input NFS_CATALOG_STRUCT* catal
 /// @return the fork.
 /***********************************************************************************/
 _Output NFS_FORK_STRUCT* NeFSParser::FindFork(_Input NFS_CATALOG_STRUCT* catalog,
-											  _Input const Char*		 name,
-											  Boolean					 isDataFork)
+											  _Input const Char* name,
+											  Boolean			 isDataFork)
 {
 	auto			 drv	  = kDiskMountpoint.A();
 	NFS_FORK_STRUCT* the_fork = nullptr;
@@ -236,7 +236,7 @@ _Output NFS_CATALOG_STRUCT* NeFSParser::CreateCatalog(_Input const Char* name)
 /// @param kind the catalog kind.
 /// @return catalog pointer.
 /***********************************************************************************/
-_Output NFS_CATALOG_STRUCT* NeFSParser::CreateCatalog(_Input const Char*  name,
+_Output NFS_CATALOG_STRUCT* NeFSParser::CreateCatalog(_Input const Char* name,
 													  _Input const Int32& flags,
 													  _Input const Int32& kind)
 {
@@ -936,7 +936,7 @@ Boolean NeFSParser::RemoveCatalog(_Input const Char* catalogName)
 VoidPtr NeFSParser::ReadCatalog(_Input _Output NFS_CATALOG_STRUCT* catalog,
 								_Input Bool						   is_rsrc_fork,
 								_Input SizeT					   dataSz,
-								_Input const Char*				   forkName)
+								_Input const Char* forkName)
 {
 	if (!catalog)
 	{
diff --git a/dev/ZKAKit/src/HardwareThreadScheduler.cc b/dev/ZKAKit/src/HardwareThreadScheduler.cc
index 5c5b8f15..84f870d0 100644
--- a/dev/ZKAKit/src/HardwareThreadScheduler.cc
+++ b/dev/ZKAKit/src/HardwareThreadScheduler.cc
@@ -162,7 +162,7 @@ namespace Kernel
 				fThreadList[idx].fKind = kHartBoot;
 			}
 		}
-		else if (idx >= cMaxHartInsideSched)
+		else if (idx >= kMaxHartInsideSched)
 		{
 			static HardwareThread* fakeThread = nullptr;
 			return {fakeThread};
diff --git a/dev/ZKAKit/src/PEFCodeMgr.cc b/dev/ZKAKit/src/PEFCodeMgr.cc
index 2aba5fbf..a2b3482a 100644
--- a/dev/ZKAKit/src/PEFCodeMgr.cc
+++ b/dev/ZKAKit/src/PEFCodeMgr.cc
@@ -14,9 +14,9 @@
 #include <NewKit/KString.h>
 
 /// @brief PEF stack size symbol.
-#define cPefStackSizeSymbol "SizeOfReserveStack"
-#define cPefHeapSizeSymbol	"SizeOfReserveHeap"
-#define cPefNameSymbol		"ProgramName"
+#define kPefStackSizeSymbol "SizeOfReserveStack"
+#define kPefHeapSizeSymbol	"SizeOfReserveHeap"
+#define kPefNameSymbol		"ProgramName"
 
 namespace Kernel
 {
@@ -58,9 +58,9 @@ namespace Kernel
 		fFile.New(const_cast<Char*>(path), kRestrictRB);
 		fPath = StringBuilder::Construct(path).Leak();
 
-		auto cPefHeader = "PEF_CONTAINER";
+		auto kPefHeader = "PEF_CONTAINER";
 
-		fCachedBlob = fFile->Read(cPefHeader);
+		fCachedBlob = fFile->Read(kPefHeader);
 
 		PEFContainer* container = reinterpret_cast<PEFContainer*>(fCachedBlob);
 
@@ -228,32 +228,32 @@ namespace Kernel
 
 	namespace Utils
 	{
-		ProcessID execute_from_image(PEFLoader& exec, const Int32& procKind) noexcept
+		ProcessID rtl_create_process(PEFLoader& exec, const Int32& procKind) noexcept
 		{
 			auto errOrStart = exec.FindStart();
 
 			if (errOrStart.Error() != kErrorSuccess)
 				return No;
 
-			UserProcess proc{};
+			UserProcess* proc = new UserProcess{errOrStart.Leak().Leak()};
 
-			proc.Image		 = errOrStart.Leak().Leak();
-			proc.Kind		 = procKind;
-			proc.StackSize	 = *(UIntPtr*)exec.FindSymbol(cPefStackSizeSymbol, kPefData);
-			proc.MemoryLimit = *(UIntPtr*)exec.FindSymbol(cPefHeapSizeSymbol, kPefData);
+			proc->Kind		  = procKind;
+			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, kProcessLen);
 
-			if (exec.FindSymbol(cPefNameSymbol, kPefData))
-				rt_copy_memory(exec.FindSymbol(cPefNameSymbol, kPefData), proc.Name, rt_string_len((Char*)exec.FindSymbol(cPefNameSymbol, kPefData)));
+			if (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/Stop.cc b/dev/ZKAKit/src/Stop.cc
index ce904988..122b4489 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::Int& id)
 	{
 		CGInit();
 
@@ -46,7 +46,7 @@ namespace Kernel
 		switch (id)
 		{
 		case RUNTIME_CHECK_PROCESS: {
-			CGDrawString("0x00000008 Process check error.", start_y, x, panic_text);
+			CGDrawString("0x00000008 Invalid process behavior, aborting.", start_y, x, panic_text);
 			break;
 		}
 		case RUNTIME_CHECK_ACPI: {
diff --git a/dev/ZKAKit/src/User.cc b/dev/ZKAKit/src/User.cc
index ef35d2f4..68bb2641 100644
--- a/dev/ZKAKit/src/User.cc
+++ b/dev/ZKAKit/src/User.cc
@@ -34,7 +34,7 @@ namespace Kernel
 			if (!password || !user)
 				return 1;
 
-			kcout << "Hashing password...\r";
+			kcout << "Hashing user password...\r";
 
 			for (Size i_pass = 0; i_pass < length; ++i_pass)
 			{
@@ -46,12 +46,13 @@ namespace Kernel
 				password[i_pass] = cur_chr | (user->IsStdUser() ? kStdUserType : kSuperUserType);
 			}
 
-			kcout << "Done hashing password!\r";
+			kcout << "Done hashing user password!\r";
 
 			return 0;
 		}
 	} // namespace Detail
 
+	/// @brief User ring constructor.
 	User::User(const Int32& sel, const Char* userName)
 		: fRing((UserRingKind)sel)
 	{
@@ -59,12 +60,14 @@ namespace Kernel
 		rt_copy_memory((VoidPtr)userName, this->fUserName, rt_string_len(userName));
 	}
 
+	/// @brief User ring constructor.
 	User::User(const UserRingKind& ringKind, const Char* userName)
 		: fRing(ringKind)
 	{
 		rt_copy_memory((VoidPtr)userName, this->fUserName, rt_string_len(userName));
 	}
 
+	/// @brief User destructor class.
 	User::~User() = default;
 
 	Bool User::Save(const UserPublicKey password_to_fill) noexcept
@@ -130,7 +133,14 @@ namespace Kernel
 		kcout << "Validating hashed passwords...\r";
 
 		// now check if the password matches.
-		return rt_string_cmp(password, this->fUserToken, rt_string_len(this->fUserToken)) == 0;
+		if (rt_string_cmp(password, this->fUserToken, rt_string_len(this->fUserToken)) == 0)
+		{
+			kcout << "Password is valid.\r";
+			return Yes;
+		}
+
+		kcout << "Password isn't valid.\r";
+		return No;
 	}
 
 	Bool User::operator==(const User& lhs)
diff --git a/dev/ZKAKit/src/UserProcessScheduler.cc b/dev/ZKAKit/src/UserProcessScheduler.cc
index b2fed635..67eac095 100644
--- a/dev/ZKAKit/src/UserProcessScheduler.cc
+++ b/dev/ZKAKit/src/UserProcessScheduler.cc
@@ -32,7 +32,7 @@ namespace Kernel
 	/// @brief Exit Code global variable.
 	/***********************************************************************************/
 
-	STATIC UInt32 kLastExitCode = 0U;
+	UInt32 kLastExitCode = 0U;
 
 	/***********************************************************************************/
 	/// @brief User Process scheduler global and external reference of thread scheduler.
@@ -61,14 +61,7 @@ namespace Kernel
 
 	Void UserProcess::Crash()
 	{
-		if (this->Status != ProcessStatusKind::kRunning)
-			return;
-
-		if (*this->Name != 0)
-		{
-			kcout << this->Name << ": crashed, error id: " << number(kErrorProcessFault) << endl;
-		}
-
+		kcout << this->Name << ": crashed, error id: " << number(kErrorProcessFault) << endl;
 		this->Exit(kErrorProcessFault);
 	}
 
@@ -78,7 +71,7 @@ namespace Kernel
 
 	UserProcess::operator bool()
 	{
-		return this->Status != ProcessStatusKind::kDead;
+		return this->Status == ProcessStatusKind::kRunning && this->Image != nullptr;
 	}
 
 	/***********************************************************************************/
@@ -319,13 +312,25 @@ namespace Kernel
 
 	SizeT UserProcessScheduler::Add(UserProcess process)
 	{
-		if (mTeam.mProcessAmount > kSchedProcessLimitPerTeam)
+		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;
+
 #ifdef __ZKA_AMD64__
 		process.VMRegister = reinterpret_cast<UIntPtr>(mm_new_heap(sizeof(PDE), No, Yes));
+
+		if (!process.VMRegister)
+		{
+			process.Crash();
+			return kErrorProcessFault;
+		}
 #endif // __ZKA_AMD64__
 
+		kcout << "Create stack_frame of: " << process.Name << endl;
+
 		process.StackFrame = reinterpret_cast<HAL::StackFramePtr>(mm_new_heap(sizeof(HAL::StackFrame), Yes, Yes));
 
 		if (!process.StackFrame)
@@ -334,18 +339,24 @@ namespace Kernel
 			return kErrorProcessFault;
 		}
 
+		kcout << "Create delegate if DLL for: " << process.Name << endl;
+
 		// Create heap according to type of process.
 		if (process.Kind == UserProcess::kExectuableDLLKind)
 		{
 			process.PefDLLDelegate = rtl_init_dll(&process);
 		}
 
+		kcout << "Validate image of: " << process.Name << endl;
+
 		if (!process.Image)
 		{
 			process.Crash();
 			return kErrorProcessFault;
 		}
 
+		kcout << "Validate stack reserve of: " << process.Name << endl;
+
 		// Get preferred stack size by app.
 		const auto kMaxStackSize = process.StackSize;
 		process.StackReserve	 = reinterpret_cast<UInt8*>(mm_new_heap(sizeof(UInt8) * kMaxStackSize, Yes, Yes));
@@ -356,13 +367,13 @@ namespace Kernel
 			return kErrorProcessFault;
 		}
 
-		++mTeam.mProcessAmount;
-
-		process.ProcessId = mTeam.mProcessAmount;
-		process.Status	  = ProcessStatusKind::kStarting;
+		process.ProcessId = 0UL;
+		process.Status	  = ProcessStatusKind::kRunning;
 
 		mTeam.AsArray()[process.ProcessId] = process;
 
+		kcout << "Create process: " << process.Name << endl;
+
 		return process.ProcessId;
 	}
 
@@ -372,6 +383,7 @@ namespace Kernel
 
 	UserProcessScheduler& UserProcessScheduler::The()
 	{
+		kcout << "Return user scheduler object.\r";
 		return kProcessScheduler;
 	}
 
@@ -387,11 +399,10 @@ namespace Kernel
 	const Bool UserProcessScheduler::Remove(ProcessID process_id)
 	{
 		// check if process is within range.
-		if (process_id > mTeam.mProcessAmount)
+		if (process_id > mTeam.mProcessList.Count())
 			return No;
 
 		mTeam.AsArray()[process_id].Status = ProcessStatusKind::kDead;
-		--mTeam.mProcessAmount;
 
 		return Yes;
 	}
@@ -424,13 +435,13 @@ namespace Kernel
 		SizeT process_index = 0; //! we store this guy to tell the scheduler how many
 								 //! things we have scheduled.
 
-		if (mTeam.mProcessAmount == 0)
+		if (mTeam.mProcessList.Empty())
 		{
 			kcout << "UserProcessScheduler::Run(): This team doesn't have any process!\r";
 			return 0;
 		}
 
-		kcout << "UserProcessScheduler::Run(): This team has process # " << number(mTeam.mProcessAmount) << endl;
+		kcout << "UserProcessScheduler::Run(): This team has a process capacity of: " << number(mTeam.mProcessList.Capacity()) << endl;
 
 		for (; process_index < mTeam.AsArray().Capacity(); ++process_index)
 		{
@@ -441,9 +452,6 @@ namespace Kernel
 			{
 				process.PTime = static_cast<Int32>(process.Affinity);
 
-				UserProcessScheduler::The().GetCurrentProcess().Leak().Status = ProcessStatusKind::kFrozen;
-				UserProcessScheduler::The().GetCurrentProcess()				  = process;
-
 				kcout << "Switch to '" << process.Name << "'.\r";
 
 				// Set current process header.
@@ -463,8 +471,6 @@ namespace Kernel
 			}
 		}
 
-		kcout << "Scheduled Process Count: " << number(process_index) << endl;
-
 		return process_index;
 	}
 
diff --git a/dev/ZKAKit/src/Utils.cc b/dev/ZKAKit/src/Utils.cc
index a3343527..f6564f38 100644
--- a/dev/ZKAKit/src/Utils.cc
+++ b/dev/ZKAKit/src/Utils.cc
@@ -210,3 +210,8 @@ namespace Kernel
 		return str;
 	}
 } // namespace Kernel
+
+EXTERN_C void* memset(void* dst, char c, Kernel::Size len)
+{
+	return Kernel::rt_set_memory(dst, c, len);
+}