ARM64: Got into the linking stage, writing missing drivers in HAL now.

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

8 files changed, 152 insertions, 29 deletions

diff --git a/Kernel/Sources/CxxAbi.cxx b/Kernel/Sources/CxxAbi.cxx
index 1e585a50..e358caca 100644
--- a/Kernel/Sources/CxxAbi.cxx
+++ b/Kernel/Sources/CxxAbi.cxx
@@ -12,21 +12,26 @@ atexit_func_entry_t __atexit_funcs[kDSOMaxObjects];
 
 uarch_t __atexit_func_count;
 
-extern "C" void __cxa_pure_virtual()
+/// @brief Dynamic Shared Object Handle.
+NewOS::UIntPtr __dso_handle;
+
+EXTERN_C void __cxa_pure_virtual()
 {
 	NewOS::kcout << "newoskrnl: C++ placeholder method.\n";
 }
 
-extern "C" void ___chkstk_ms()
+EXTERN_C void ___chkstk_ms()
 {
-	while (1)
+	while (true)
 	{
-		asm("cli");
-		asm("hlt");
 	}
 }
 
-extern "C" int atexit(void (*f)(void*), void* arg, void* dso)
+#ifdef __NEWOS_ARM64__
+#define atexit __aeabi_atexit
+#endif
+
+EXTERN_C int atexit(void (*f)(void*), void* arg, void* dso)
 {
 	if (__atexit_func_count >= kDSOMaxObjects)
 		return -1;
@@ -40,7 +45,7 @@ extern "C" int atexit(void (*f)(void*), void* arg, void* dso)
 	return 0;
 }
 
-extern "C" void __cxa_finalize(void* f)
+EXTERN_C void __cxa_finalize(void* f)
 {
 	uarch_t i = __atexit_func_count;
 	if (!f)
@@ -68,19 +73,19 @@ extern "C" void __cxa_finalize(void* f)
 
 namespace cxxabiv1
 {
-	extern "C" int __cxa_guard_acquire(__guard* g)
+	EXTERN_C int __cxa_guard_acquire(__guard* g)
 	{
 		(void)g;
 		return 0;
 	}
 
-	extern "C" int __cxa_guard_release(__guard* g)
+	EXTERN_C int __cxa_guard_release(__guard* g)
 	{
 		*(char*)g = 1;
 		return 0;
 	}
 
-	extern "C" void __cxa_guard_abort(__guard* g)
+	EXTERN_C void __cxa_guard_abort(__guard* g)
 	{
 		(void)g;
 	}
diff --git a/Kernel/Sources/FS/NewFS.cxx b/Kernel/Sources/FS/NewFS.cxx
index 2938c53f..3d9cd2e7 100644
--- a/Kernel/Sources/FS/NewFS.cxx
+++ b/Kernel/Sources/FS/NewFS.cxx
@@ -8,6 +8,7 @@
 
 #include <Builtins/AHCI/AHCI.hxx>
 #include <Builtins/ATA/ATA.hxx>
+#include <Builtins/Flash/Flash.hxx>
 #include <FSKit/NewFS.hxx>
 #include <KernelKit/HError.hpp>
 #include <NewKit/Crc32.hpp>
diff --git a/Kernel/Sources/HalPageAlloc.cxx b/Kernel/Sources/HalPageAlloc.cxx
new file mode 100644
index 00000000..3df68501
--- /dev/null
+++ b/Kernel/Sources/HalPageAlloc.cxx
@@ -0,0 +1,109 @@
+/* -------------------------------------------
+
+	Copyright Zeta Electronics Corporation
+
+------------------------------------------- */
+
+#include <ArchKit/ArchKit.hpp>
+
+#ifdef __NEWOS_AMD64__
+#include <HALKit/AMD64/HalPageAlloc.hpp>
+#elif defined(__NEWOS_ARM64__)
+#include <HALKit/ARM64/HalPageAlloc.hpp>
+#endif
+
+#include <NewKit/Defines.hpp>
+#include <NewKit/KernelCheck.hpp>
+
+STATIC NewOS::Boolean kAllocationInProgress = false;
+
+namespace NewOS
+{
+	namespace HAL
+	{
+		namespace Detail
+		{
+			struct VirtualMemoryHeader
+			{
+				UInt32	Magic;
+				Boolean Present;
+				Boolean ReadWrite;
+				Boolean User;
+				SizeT	PageSize;
+			};
+
+			struct VirtualMemoryHeaderTraits
+			{
+				/// @brief Get next header.
+				/// @param current
+				/// @return
+				VirtualMemoryHeader* Next(VirtualMemoryHeader* current)
+				{
+					return current + sizeof(PTE) + current->PageSize;
+				}
+
+				/// @brief Get previous header.
+				/// @param current
+				/// @return
+				VirtualMemoryHeader* Prev(VirtualMemoryHeader* current)
+				{
+					return current - sizeof(PTE) - current->PageSize;
+				}
+			};
+		} // namespace Detail
+
+		/// @brief Allocates a new page of memory.
+		/// @param sz the size of it.
+		/// @param rw read/write flag.
+		/// @param user user flag.
+		/// @return the page table of it.
+		STATIC auto hal_try_alloc_new_page(Boolean rw, Boolean user, SizeT size) -> VoidPtr
+		{
+			if (kAllocationInProgress)
+				return nullptr;
+
+			kAllocationInProgress = true;
+
+			constexpr auto cVMTMagic = 0xDEEFD00D;
+
+			///! fetch from the start.
+			Detail::VirtualMemoryHeader*	  vmHeader = reinterpret_cast<Detail::VirtualMemoryHeader*>(kKernelVirtualStart);
+			Detail::VirtualMemoryHeaderTraits traits;
+
+			while (vmHeader->Present &&
+				   vmHeader->Magic != cVMTMagic)
+			{
+				vmHeader = traits.Next(vmHeader);
+			}
+
+			vmHeader->Magic		= cVMTMagic;
+			vmHeader->Present	= true;
+			vmHeader->ReadWrite = rw;
+			vmHeader->User		= user;
+			vmHeader->PageSize	= size;
+
+			kAllocationInProgress = false;
+
+			return reinterpret_cast<VoidPtr>(vmHeader);
+		}
+
+		/// @brief Allocate a new page to be used by the OS.
+		/// @param rw read/write bit.
+		/// @param user user bit.
+		/// @return
+		auto hal_alloc_page(Boolean rw, Boolean user, SizeT size) -> VoidPtr
+		{
+			/// Wait for a ongoing allocation to complete.
+			while (kAllocationInProgress)
+			{
+				;
+			}
+
+			if (size == 0)
+				++size;
+
+			/// allocate new page.
+			return hal_try_alloc_new_page(rw, user, size);
+		}
+	} // namespace HAL
+} // namespace NewOS
diff --git a/Kernel/Sources/KeMain.cxx b/Kernel/Sources/KeMain.cxx
index fb127271..418bda20 100644
--- a/Kernel/Sources/KeMain.cxx
+++ b/Kernel/Sources/KeMain.cxx
@@ -214,14 +214,15 @@ EXTERN_C NewOS::Void KeMain(NewOS::Void)
 	NewOS::Detail::FilesystemInstaller installer; // automatic filesystem creation.
 
 	NewOS::Detail::ke_launch_srv();
-	
-	// fetch system cores.
+
+#if __NEWOS_AMD64__
+    /// fetch system cores.
 	NewOS::HAL::hal_system_get_cores(kHandoverHeader->f_HardwareTables.f_RsdPtr);
+#else
+    /// ... or fetch using CoreBoot.
+#endif
 
-	// spin forever.
-	while (Yes)
-	{
-		// start scheduling.
-		NewOS::ProcessHelper::StartScheduling();
-	}
+	NewOS::ProcessHelper::StartScheduling();
+
+	NewOS::ke_stop(RUNTIME_CHECK_BOOTSTRAP);
 }
diff --git a/Kernel/Sources/KernelCheck.cxx b/Kernel/Sources/KernelCheck.cxx
index 10c263b8..e0e61ab2 100644
--- a/Kernel/Sources/KernelCheck.cxx
+++ b/Kernel/Sources/KernelCheck.cxx
@@ -9,12 +9,14 @@
 #include <NewKit/KernelCheck.hpp>
 #include <NewKit/String.hpp>
 
-extern "C" [[noreturn]] void ke_wait_for_debugger()
+EXTERN_C [[noreturn]] void ke_wait_for_debugger()
 {
 	while (true)
 	{
+#ifdef __NEWOS_AMD64__
 		NewOS::HAL::rt_cli();
 		NewOS::HAL::rt_halt();
+#endif
 	}
 }
 
@@ -52,7 +54,7 @@ namespace NewOS
 		}
 		case RUNTIME_CHECK_BOOTSTRAP: {
 			kcout << "*** CAUSE: RUNTIME_CHECK_BOOTSTRAP *** \r";
-			kcout << "*** WHAT: INVALID BOOT SEQUENCE. *** \r";
+			kcout << "*** WHAT: END OF CODE. *** \r";
 			break;
 		}
 		case RUNTIME_CHECK_HANDSHAKE: {
diff --git a/Kernel/Sources/PageManager.cxx b/Kernel/Sources/PageManager.cxx
index 118fbe53..331be178 100644
--- a/Kernel/Sources/PageManager.cxx
+++ b/Kernel/Sources/PageManager.cxx
@@ -7,8 +7,10 @@
 #include <KernelKit/DebugOutput.hpp>
 #include <NewKit/PageManager.hpp>
 
-#ifdef __x86_64__
+#ifdef __NEWOS_AMD64__
 #include <HALKit/AMD64/HalPageAlloc.hpp>
+#elif defined(__NEWOS_ARM64__)
+#include <HALKit/ARM64/Processor.hxx>
 #endif // ifdef __x86_64__
 
 //! null deref will throw (Page Zero detected, aborting app!)
diff --git a/Kernel/Sources/Pmm.cxx b/Kernel/Sources/Pmm.cxx
index e794b57b..f3535968 100644
--- a/Kernel/Sources/Pmm.cxx
+++ b/Kernel/Sources/Pmm.cxx
@@ -7,6 +7,10 @@
 #include <KernelKit/DebugOutput.hpp>
 #include <NewKit/Pmm.hpp>
 
+#if defined(__NEWOS_ARM64__)
+#include <HALKit/ARM64/Processor.hxx>
+#endif
+
 namespace NewOS
 {
 	/// @brief Pmm constructor.
diff --git a/Kernel/Sources/Utils.cxx b/Kernel/Sources/Utils.cxx
index 66d7582b..a307d416 100644
--- a/Kernel/Sources/Utils.cxx
+++ b/Kernel/Sources/Utils.cxx
@@ -6,7 +6,6 @@
 
 #include <NewKit/Utils.hpp>
 #include <KernelKit/DebugOutput.hpp>
-#include <cstddef>
 
 namespace NewOS
 {
@@ -186,7 +185,7 @@ namespace NewOS
 
 	voidPtr rt_string_in_string(const char* in, const char* needle)
 	{
-		for (size_t i = 0; i < rt_string_len(in); ++i)
+		for (SizeT i = 0; i < rt_string_len(in); ++i)
 		{
 			if (rt_string_cmp(in + i, needle, rt_string_len(needle)) == 0)
 				return reinterpret_cast<voidPtr>(const_cast<char*>(in + i));
@@ -216,38 +215,38 @@ namespace NewOS
 ////////////////////////////////////////////////////////////////////////////////////////
 
 /// @brief memset in C++
-EXTERN_C void memset(void* dst, char src, size_t len)
+EXTERN_C void memset(void* dst, char src, NewOS::SizeT len)
 {
 	NewOS::rt_set_memory(dst, src, len);
 }
 
 /// @brief memcpy in C++
-EXTERN_C void memcpy(void* dst, void* src, size_t len)
+EXTERN_C void memcpy(void* dst, void* src, NewOS::SizeT len)
 {
 	NewOS::rt_copy_memory(src, dst, len);
 }
 
 /// @brief memmove in C++
-EXTERN_C void* memmove(void* dst, void* src, size_t len)
+EXTERN_C void* memmove(void* dst, void* src, NewOS::SizeT len)
 {
 	NewOS::rt_copy_memory(src, dst, len);
 	return dst;
 }
 
 /// @brief strlen definition in C++.
-EXTERN_C size_t strlen(const char* whatToCheck)
+EXTERN_C NewOS::SizeT strlen(const char* whatToCheck)
 {
 	return NewOS::rt_string_len(whatToCheck);
 }
 
 /// @brief memcmp in C++
-EXTERN_C NewOS::SizeT memcmp(void* dst, void* src, size_t len)
+EXTERN_C NewOS::SizeT memcmp(void* dst, void* src, NewOS::SizeT len)
 {
 	return NewOS::rt_string_cmp((char*)src, (char*)dst, len);
 }
 
 /// @brief strcmp in C++
-EXTERN_C NewOS::SizeT strcmp(char* dst, char* src, size_t len)
+EXTERN_C NewOS::SizeT strcmp(char* dst, char* src, NewOS::SizeT len)
 {
 	return NewOS::rt_string_cmp(src, dst, len);
 }