MHR-36: A set of major fixes for bootloader and kernel alongside new

implementations.

- Implement realloc for kernel scheduler improvements.
- Fixed readAll on bootloader's BFileReader.
- Add resources for zeta installation.
- Add STB header.
- Process Heap which replaced the previous User Heap.

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

14 files changed, 86 insertions, 44 deletions

diff --git a/Kernel/HALKit/AMD64/HalKernelMain.cxx b/Kernel/HALKit/AMD64/HalKernelMain.cxx
index dd08b7fb..a279b776 100644
--- a/Kernel/HALKit/AMD64/HalKernelMain.cxx
+++ b/Kernel/HALKit/AMD64/HalKernelMain.cxx
@@ -12,14 +12,14 @@
 #include <KernelKit/KernelHeap.hpp>
 #include <KernelKit/PEFCodeManager.hxx>
 #include <KernelKit/ProcessScheduler.hxx>
-#include <KernelKit/UserHeap.hpp>
+#include <KernelKit/ProcessHeap.hpp>
 #include <NewKit/Json.hpp>
 #include <Modules/CoreCG/Accessibility.hxx>
 #include <KernelKit/CodeManager.hpp>
 #include <Modules/ACPI/ACPIFactoryInterface.hxx>
 #include <NetworkKit/IPCEP.hxx>
 
-#define KERNEL_INIT(X) \
+#define mInitKernel(X) \
 	X;                 \
 	Kernel::ke_stop(RUNTIME_CHECK_BOOTSTRAP);
 
@@ -212,5 +212,5 @@ EXTERN_C void hal_init_platform(
 
 	Kernel::HAL::hal_system_get_cores(kHandoverHeader->f_HardwareTables.f_RsdPtr);
 
-	KERNEL_INIT(KeMain());
+	mInitKernel(KeMain());
 }
diff --git a/Kernel/HALKit/ARM64/HalKernelMain.cxx b/Kernel/HALKit/ARM64/HalKernelMain.cxx
index 3b27f420..3fb18737 100644
--- a/Kernel/HALKit/ARM64/HalKernelMain.cxx
+++ b/Kernel/HALKit/ARM64/HalKernelMain.cxx
@@ -12,7 +12,7 @@
 #include <KernelKit/KernelHeap.hpp>
 #include <KernelKit/PEFCodeManager.hxx>
 #include <KernelKit/ProcessScheduler.hxx>
-#include <KernelKit/UserHeap.hpp>
+#include <KernelKit/ProcessHeap.hpp>
 #include <NewKit/Json.hpp>
 #include <Modules/CoreCG/Accessibility.hxx>
 #include <KernelKit/CodeManager.hpp>
diff --git a/Kernel/KernelKit/KernelHeap.hpp b/Kernel/KernelKit/KernelHeap.hpp
index 0d2f2188..dad0b83e 100644
--- a/Kernel/KernelKit/KernelHeap.hpp
+++ b/Kernel/KernelKit/KernelHeap.hpp
@@ -15,29 +15,34 @@
 namespace Kernel
 {
 	/// @brief Declare pointer as free.
-	/// @param heapPtr the pointer.
+	/// @param allocatedPtr the pointer.
 	/// @return
 	Int32 ke_delete_ke_heap(voidPtr allocatedPtr);
 
+	/// @brief Declare a new size for allocatedPtr.
+	/// @param allocatedPtr the pointer.
+	/// @return
+	voidPtr ke_realloc_ke_heap(voidPtr allocatedPtr, SizeT newSz);
+
 	/// @brief Check if pointer is a valid kernel pointer.
-	/// @param heapPtr the pointer
+	/// @param allocatedPtr the pointer
 	/// @return if it exists.
-	Boolean ke_is_valid_heap(VoidPtr ptr);
+	Boolean ke_is_valid_heap(VoidPtr allocatedPtr);
 
 	/// @brief allocate chunk of memory.
 	/// @param sz size of pointer
 	/// @param rw read write (true to enable it)
 	/// @param user is it accesible by user processes?
 	/// @return the pointer
-	voidPtr ke_new_ke_heap(SizeT sz, const bool rw, const bool user);
+	voidPtr ke_new_ke_heap(const SizeT sz, const Bool rw, const Bool user);
 
 	/// @brief Protect the heap with a CRC value.
-	/// @param heapPtr HIB pointer.
+	/// @param allocatedPtr pointer.
 	/// @return if it valid: point has crc now., otherwise fail.
-	Boolean ke_protect_ke_heap(VoidPtr heapPtr);
+	Boolean ke_protect_ke_heap(VoidPtr allocatedPtr);
 
 	/// @brief Makes a kernel heap page.
-	/// @param heapPtr
+	/// @param allocatedPtr the page pointer.
 	/// @return
-	Int32 ke_make_ke_page(VoidPtr heapPtr);
+	Int32 ke_make_ke_page(VoidPtr allocatedPtr);
 } // namespace Kernel
diff --git a/Kernel/KernelKit/UserHeap.hpp b/Kernel/KernelKit/ProcessHeap.hpp
index 6f125fdc..0682d969 100644
--- a/Kernel/KernelKit/UserHeap.hpp
+++ b/Kernel/KernelKit/ProcessHeap.hpp
@@ -14,8 +14,8 @@
 #include <NewKit/Pmm.hpp>
 
 /// @version 5/11/23
-/// @file UserHeap.hpp
-/// @brief memory heap for user programs.
+/// @file ProcessHeap.hpp
+/// @brief memory heap for user processes.
 
 #define kUserHeapMaxSz (4096)
 #define kUserHeapMag   (0xFAF0FEF0)
@@ -24,8 +24,6 @@ namespace Kernel
 {
 	typedef enum
 	{
-		/// @brief Driver only heap.
-		kUserHeapDriver = 0x2,
 		/// @brief Shared heap.
 		kUserHeapShared = 0x4,
 		/// @brief User and private heap.
diff --git a/Kernel/KernelKit/ProcessScheduler.hxx b/Kernel/KernelKit/ProcessScheduler.hxx
index 7616e91a..578dc163 100644
--- a/Kernel/KernelKit/ProcessScheduler.hxx
+++ b/Kernel/KernelKit/ProcessScheduler.hxx
@@ -10,7 +10,7 @@
 #include <ArchKit/ArchKit.hpp>
 #include <KernelKit/LockDelegate.hpp>
 #include <KernelKit/PermissionSelector.hxx>
-#include <KernelKit/UserHeap.hpp>
+#include <KernelKit/ProcessHeap.hpp>
 #include <NewKit/MutableArray.hpp>
 
 #define kSchedMinMicroTime (AffinityKind::kHartStandard)
@@ -254,8 +254,8 @@ namespace Kernel
 		ProcessTeam& CurrentTeam();
 
 	public:
-		SizeT Add(Ref<ProcessHeader>& headerRef);
-		bool  Remove(SizeT headerIndex);
+		SizeT Add(Ref<ProcessHeader>& processRef);
+		Bool Remove(SizeT processSlot);
 
 	public:
 		Ref<ProcessHeader>& TheCurrent();
diff --git a/Kernel/Modules/CoreCG/CoreCG.hxx b/Kernel/Modules/CoreCG/CoreCG.hxx
index b77a2f28..23ebf6c2 100644
--- a/Kernel/Modules/CoreCG/CoreCG.hxx
+++ b/Kernel/Modules/CoreCG/CoreCG.hxx
@@ -27,7 +27,7 @@
 			*(((volatile Kernel::UInt32*)(kHandoverHeader->f_GOP.f_The +              \
 										  4 * kHandoverHeader->f_GOP.f_PixelPerLine * \
 											  i +                                     \
-										  4 * u))) |= ImgPtr[__GXCursor];             \
+										  4 * u))) |= (ImgPtr)[__GXCursor];             \
                                                                                       \
 			++__GXCursor;                                                             \
 		}                                                                             \
@@ -44,7 +44,7 @@
 			*(((volatile Kernel::UInt32*)(kHandoverHeader->f_GOP.f_The +              \
 										  4 * kHandoverHeader->f_GOP.f_PixelPerLine * \
 											  i +                                     \
-										  4 * u))) = ImgPtr[__GXCursor];              \
+										  4 * u))) = (ImgPtr)[__GXCursor];              \
                                                                                       \
 			++__GXCursor;                                                             \
 		}                                                                             \
diff --git a/Kernel/NewKit/NewKit.hpp b/Kernel/NewKit/NewKit.hpp
index bf04eb0b..8ca19ec8 100644
--- a/Kernel/NewKit/NewKit.hpp
+++ b/Kernel/NewKit/NewKit.hpp
@@ -18,5 +18,5 @@
 #include <NewKit/OwnPtr.hpp>
 #include <NewKit/Ref.hpp>
 #include <NewKit/Stream.hpp>
-#include <KernelKit/UserHeap.hpp>
+#include <KernelKit/ProcessHeap.hpp>
 #include <NewKit/Utils.hpp>
diff --git a/Kernel/Sources/KeMain.cxx b/Kernel/Sources/KeMain.cxx
index 0ba882af..d4c02990 100644
--- a/Kernel/Sources/KeMain.cxx
+++ b/Kernel/Sources/KeMain.cxx
@@ -17,7 +17,7 @@
 #include <KernelKit/PEF.hpp>
 #include <KernelKit/PEFCodeManager.hxx>
 #include <KernelKit/ProcessScheduler.hxx>
-#include <KernelKit/UserHeap.hpp>
+#include <KernelKit/ProcessHeap.hpp>
 #include <NewKit/Json.hpp>
 #include <NewKit/KernelCheck.hpp>
 #include <NewKit/String.hpp>
diff --git a/Kernel/Sources/KernelHeap.cxx b/Kernel/Sources/KernelHeap.cxx
index 295c4e76..2cf89480 100644
--- a/Kernel/Sources/KernelHeap.cxx
+++ b/Kernel/Sources/KernelHeap.cxx
@@ -11,7 +11,7 @@
 #include <NewKit/PageManager.hpp>
 
 //! @file KernelHeap.cxx
-//! @brief Kernel allocator.
+//! @brief Kernel heap allocator.
 
 #define kKernelHeapMagic		   (0xD4D7D5)
 #define kKernelHeapHeaderPaddingSz (16U)
@@ -47,23 +47,47 @@ namespace Kernel
 		typedef HeapInformationBlock* HeapInformationBlockPtr;
 	} // namespace Detail
 
+	/// @brief Declare a new size for allocatedPtr.
+	/// @param allocatedPtr the pointer.
+	/// @return
+	voidPtr ke_realloc_ke_heap(voidPtr allocatedPtr, SizeT newSz)
+	{
+		if (!allocatedPtr || newSz < 1)
+			return nullptr;
+
+		Detail::HeapInformationBlockPtr heapInfoBlk =
+			reinterpret_cast<Detail::HeapInformationBlockPtr>(
+				(UIntPtr)allocatedPtr - sizeof(Detail::HeapInformationBlock));
+
+		heapInfoBlk->fTargetPtrSize = newSz;
+
+		if (heapInfoBlk->fCRC32 > 0)
+		{
+		    MUST_PASS(ke_protect_ke_heap(allocatedPtr));
+		}
+
+		return allocatedPtr;
+	}
+
 	/// @brief allocate chunk of memory.
 	/// @param sz size of pointer
 	/// @param rw read write (true to enable it)
 	/// @param user is it accesible by user processes?
 	/// @return the pointer
-	VoidPtr ke_new_ke_heap(SizeT sz, const bool rw, const bool user)
+	VoidPtr ke_new_ke_heap(const SizeT sz, const bool rw, const bool user)
 	{
-		if (sz == 0)
-			++sz;
+	   auto szFix = sz;
+
+		if (szFix == 0)
+			++szFix;
 
-		auto wrapper = kHeapPageManager.Request(rw, user, false, sz);
+		auto wrapper = kHeapPageManager.Request(rw, user, false, szFix);
 
 		Detail::HeapInformationBlockPtr heapInfo =
 			reinterpret_cast<Detail::HeapInformationBlockPtr>(
 				wrapper.VirtualAddress());
 
-		heapInfo->fTargetPtrSize = sz;
+		heapInfo->fTargetPtrSize = szFix;
 		heapInfo->fMagic		 = kKernelHeapMagic;
 		heapInfo->fCRC32		 = 0; // dont fill it for now.
 		heapInfo->fTargetPtr	 = wrapper.VirtualAddress();
diff --git a/Kernel/Sources/UserHeap.cxx b/Kernel/Sources/ProcessHeap.cxx
index 453d1f30..b5988c5f 100644
--- a/Kernel/Sources/UserHeap.cxx
+++ b/Kernel/Sources/ProcessHeap.cxx
@@ -5,12 +5,12 @@
 ------------------------------------------- */
 
 #include <KernelKit/ProcessScheduler.hxx>
-#include <KernelKit/UserHeap.hpp>
+#include <KernelKit/ProcessHeap.hpp>
 #include <NewKit/PageManager.hpp>
 
 #define kHeapHeaderPaddingSz (16U)
 
-/// @file UserHeap.cxx
+/// @file ProcessHeap.cxx
 /// @brief User Heap Manager, Process heap allocator.
 /// @note if you want to look at the kernel allocator, please look for
 /// KernelHeap.cxx
diff --git a/Kernel/Sources/ProcessScheduler.cxx b/Kernel/Sources/ProcessScheduler.cxx
index 98851d41..f8330ae8 100644
--- a/Kernel/Sources/ProcessScheduler.cxx
+++ b/Kernel/Sources/ProcessScheduler.cxx
@@ -206,15 +206,23 @@ namespace Kernel
 		if (mTeam.AsArray().Count() > kSchedProcessLimitPerTeam)
 			return -kErrorOutOfTeamSlot;
 
-		kcout << "ProcessScheduler::Add(Ref<ProcessHeader>& process)\r";
+		kcout << "ProcessScheduler:: adding process to team...\r";
 
 		/// Create heap according to type of process.
 		if (process.Leak().Kind == ProcessHeader::kAppKind)
+		{
 			process.Leak().HeapPtr = rt_new_heap(kUserHeapUser | kUserHeapRw);
+		}
 		else if (process.Leak().Kind == ProcessHeader::kShLibKind)
+		{
 			process.Leak().HeapPtr = rt_new_heap(kUserHeapUser | kUserHeapRw | kUserHeapShared);
+		}
 		else
-			process.Leak().HeapPtr = rt_new_heap(kUserHeapDriver | kUserHeapRw);
+		{
+		    // something went wrong, do not continue, process kind is incorrect.
+			process.Leak().Crash();
+			return -kErrorProcessFault;
+		}
 
 		process.Leak().StackFrame = reinterpret_cast<HAL::StackFrame*>(
 			ke_new_ke_heap(sizeof(HAL::StackFrame), true, false));
@@ -226,22 +234,28 @@ namespace Kernel
 		process.Leak().ProcessId  = (mTeam.AsArray().Count() - 1);
 		process.Leak().HeapCursor = process.Leak().HeapPtr;
 
-		mTeam.AsArray().Add(process);
+		MUST_PASS(mTeam.AsArray().Add(process));
 
-		return mTeam.AsArray().Count() - 1;
+		return (mTeam.AsArray().Count() - 1);
 	}
 
 	/// @brief Remove process from list.
-	/// @param process
-	/// @return
-	bool ProcessScheduler::Remove(SizeT process)
+	/// @param processSlot process slot inside team.
+	/// @retval true process was removed.
+	/// @retval false process doesn't exist in team.
+	Bool ProcessScheduler::Remove(SizeT processSlot)
 	{
-		if (process > mTeam.AsArray().Count())
+	    // check if process is within range.
+		if (processSlot > mTeam.AsArray().Count())
+			return false;
+
+		// also check if the process isn't a dummy one.
+		if (mTeam.AsArray()[processSlot].Leak().Leak().Image == nullptr)
 			return false;
 
-		kcout << "ProcessScheduler::Remove(SizeT process)\r";
+		kcout << "ProcessScheduler: removing process\r";
 
-		return mTeam.AsArray().Remove(process);
+		return mTeam.AsArray().Remove(processSlot);
 	}
 
 	/// @brief Run scheduler.
diff --git a/Kernel/amd64-efi.make b/Kernel/amd64-efi.make
index 6cb94ac9..b25685e2 100644
--- a/Kernel/amd64-efi.make
+++ b/Kernel/amd64-efi.make
@@ -5,8 +5,8 @@
 
 CC			= x86_64-w64-mingw32-g++
 LD			= x86_64-w64-mingw32-ld
-CCFLAGS		= -c -fPIC -ffreestanding -D__NEWOS_AMD64__ -mno-red-zone -fno-rtti -fno-exceptions \
-			-std=c++20 -D__NEWOS_SUPPORT_NX__ -D__FSKIT_USE_NEWFS__ -D__KERNEL__ -D__HAVE_MAHROUSS_APIS__ -D__MAHROUSS__ -I./
+CCFLAGS		= -fshort-wchar -c -fPIC -ffreestanding -D__NEWOS_AMD64__ -mno-red-zone -fno-rtti -fno-exceptions \
+			-std=c++20 -D__NEWOS_SUPPORT_NX__ -I../Vendor  -D__FSKIT_USE_NEWFS__ -D__KERNEL__ -D__HAVE_MAHROUSS_APIS__ -D__MAHROUSS__ -I./
 
 ASM 		= nasm
 
diff --git a/Kernel/arm64-efi.make b/Kernel/arm64-efi.make
index cf46cee6..1e153078 100644
--- a/Kernel/arm64-efi.make
+++ b/Kernel/arm64-efi.make
@@ -5,7 +5,7 @@
 
 CC			= clang++
 LD			= lld-link
-CCFLAGS		= -c -ffreestanding -MMD -mno-red-zone -D__NEWOS_ARM64__ -fno-rtti -fno-exceptions -I./ \
+CCFLAGS		= -fshort-wchar -c -ffreestanding -MMD -mno-red-zone -D__NEWOS_ARM64__ -fno-rtti -fno-exceptions -I./ \
 			 -target aarch64-unknown-windows \
 				-std=c++20 -D__FSKIT_USE_NEWFS__ -D__ZETA_MACHINE__ -D__KERNEL__ -D__HAVE_MAHROUSS_APIS__ -D__MAHROUSS__
 
diff --git a/Kernel/compile_flags.txt b/Kernel/compile_flags.txt
index de13f8f6..fd4c0d75 100644
--- a/Kernel/compile_flags.txt
+++ b/Kernel/compile_flags.txt
@@ -4,3 +4,4 @@
 -I./
 -I$(HOME)/
 -D__NEWOS_AMD64__
+-I../Vendor