Kernel: Update SPECIFICATION.TXT, Implement Shared objects primitives.

Kernel: Working on EFI reimplementation.

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

4 files changed, 156 insertions, 111 deletions

diff --git a/Private/Source/CodeManager.cxx b/Private/Source/CodeManager.cxx
index 1928683b..f1c6840e 100644
--- a/Private/Source/CodeManager.cxx
+++ b/Private/Source/CodeManager.cxx
@@ -7,138 +7,156 @@
  * 	========================================================
  */
 
-#include <KernelKit/FileManager.hpp>
+#include "NewKit/Defines.hpp"
+#include "NewKit/Panic.hpp"
 #include <KernelKit/CodeManager.hpp>
 #include <KernelKit/DebugOutput.hpp>
+#include <KernelKit/FileManager.hpp>
 #include <KernelKit/ProcessManager.hpp>
+#include <NewKit/ErrorID.hpp>
 #include <NewKit/KHeap.hpp>
-#include <NewKit/String.hpp>
 #include <NewKit/OwnPtr.hpp>
-#include <NewKit/ErrorID.hpp>
+#include <NewKit/String.hpp>
 
 namespace hCore
 {
-    namespace Detail
-    {
-        UInt32 rt_get_pef_platform(void) noexcept
-        {
+namespace Detail
+{
+UInt32 rt_get_pef_platform(void) noexcept
+{
 #ifdef __32x0__
-            return kPefArch32x0;
+    return kPefArch32x0;
 #elif defined(__64x0__)
-	    return kPefArch64x0;
+    return kPefArch64x0;
 #elif defined(__x86_64__)
-            return kPefArchAMD64;
+    return kPefArchAMD64;
 #else
-            return kPefArchInvalid;
+    return kPefArchInvalid;
 #endif // __POWER || __x86_64__
-        }
-    }
+}
+} // namespace Detail
 
-    PEFLoader::PEFLoader(const char* path)
-        : fCachedBlob(nullptr), fBad(false)
-    {
-        OwnPtr<FileStream<char>> file;
-		
-        file.New(const_cast<Char*>(path));
+PEFLoader::PEFLoader(const VoidPtr blob) : fCachedBlob(nullptr)
+{
+    fCachedBlob = blob;
+    fBad = false;
 
-        if (StringBuilder::Equals(file->MIME(), this->MIME()))
-        {
-        	fPath = StringBuilder::Construct(path).Leak();
-        	
-            fCachedBlob = file->ReadAll();
-
-            PEFContainer* container = reinterpret_cast<PEFContainer*>(fCachedBlob);
-
-            auto fFree = [&]() -> void {
-                kcout << "CodeManager: Warning: Bad executable, program will not be started!\n";
-                fBad = true;
-
-                kernel_delete_ptr(fCachedBlob);
-                
-                fCachedBlob = nullptr;
-            };
-
-            if (container->Cpu == Detail::rt_get_pef_platform() &&
-                container->Magic[0] == kPefMagic[0] &&
-                container->Magic[1] == kPefMagic[1] &&
-                container->Magic[2] == kPefMagic[2] &&
-                container->Abi == kPefAbi)
-            {
-                if (container->Kind != kPefKindObject &&
-                    container->Kind != kPefKindDebug)
-                {
-                    kcout << "CodeManager: Info: Good executable. can proceed.\n";
-                    return;
-                }
-            }
+    MUST_PASS(fCachedBlob);
+}
 
-            fFree();
-        }
-    }
+PEFLoader::PEFLoader(const char *path) : fCachedBlob(nullptr), fBad(false)
+{
+    OwnPtr<FileStream<char>> file;
 
-    PEFLoader::~PEFLoader()
-    {
-        if (fCachedBlob)
-            kernel_delete_ptr(fCachedBlob);
-    }
+    file.New(const_cast<Char *>(path));
 
-    VoidPtr PEFLoader::FindSymbol(const char* name, Int32 kind)
+    if (StringBuilder::Equals(file->MIME(), this->MIME()))
     {
-        if (!fCachedBlob ||
-            fBad)
-            return nullptr;
+        fPath = StringBuilder::Construct(path).Leak();
 
-        PEFContainer* container = reinterpret_cast<PEFContainer*>(fCachedBlob);
+        fCachedBlob = file->ReadAll();
 
-        PEFCommandHeader* container_header = reinterpret_cast<PEFCommandHeader*>((UIntPtr)fCachedBlob + sizeof(PEFContainer));
+        PEFContainer *container = reinterpret_cast<PEFContainer *>(fCachedBlob);
 
-        for (SizeT index = 0; index < container->Count; ++index)
-        {
-            kcout << "Iterating over container at index: " << StringBuilder::FromInt("%", index) << ", name: " << container_header->Name << "\n";
+        auto fFree = [&]() -> void {
+            kcout << "CodeManager: Warning: Bad executable, program will not be started!\n";
+            fBad = true;
 
-            if (StringBuilder::Equals(container_header->Name, name))
-            {
-                kcout << "Found potential container, checking for validity.\n";
+            kernel_delete_ptr(fCachedBlob);
 
-                if (container_header->Kind == kind)
-                    return static_cast<UIntPtr*>(fCachedBlob) + container_header->Offset;
+            fCachedBlob = nullptr;
+        };
 
-                continue;
+        if (container->Cpu == Detail::rt_get_pef_platform() && container->Magic[0] == kPefMagic[0] &&
+            container->Magic[1] == kPefMagic[1] && container->Magic[2] == kPefMagic[2] && container->Abi == kPefAbi)
+        {
+            if (container->Kind != kPefKindObject && container->Kind != kPefKindDebug)
+            {
+                kcout << "CodeManager: Info: Good executable. can proceed.\n";
+                return;
             }
         }
 
-        return nullptr;
+        fFree();
     }
+}
 
-    ErrorOr<VoidPtr> PEFLoader::LoadStart()
-    {
-        if (auto sym = this->FindSymbol("__start", kPefCode); sym)
-            return ErrorOr<VoidPtr>(sym);
+PEFLoader::~PEFLoader()
+{
+    if (fCachedBlob)
+        kernel_delete_ptr(fCachedBlob);
+}
 
-        return ErrorOr<VoidPtr>(H_EXEC_ERROR);
-    }
+VoidPtr PEFLoader::FindSymbol(const char *name, Int32 kind)
+{
+    if (!fCachedBlob || fBad)
+        return nullptr;
+
+    PEFContainer *container = reinterpret_cast<PEFContainer *>(fCachedBlob);
 
-    bool PEFLoader::IsLoaded() noexcept { return !fBad && fCachedBlob; }
+    PEFCommandHeader *container_header =
+        reinterpret_cast<PEFCommandHeader *>((UIntPtr)fCachedBlob + sizeof(PEFContainer));
 
-    namespace Utils
+    for (SizeT index = 0; index < container->Count; ++index)
     {
-        bool execute_from_image(PEFLoader& exec) noexcept
-        {
-            auto errOrStart = exec.LoadStart();
+        kcout << "Iterating over container at index: " << StringBuilder::FromInt("%", index)
+              << ", name: " << container_header->Name << "\n";
 
-            if (errOrStart.Error() != 0)
-                return false;
+        if (StringBuilder::Equals(container_header->Name, name))
+        {
+            kcout << "Found potential container, checking for validity.\n";
 
-            Process proc(errOrStart.Leak().Leak());
-            Ref<Process> refProc = proc;
+            if (container_header->Kind == kind)
+                return static_cast<UIntPtr *>(fCachedBlob) + container_header->Offset;
 
-            return ProcessManager::Shared().Leak().Add(refProc);
+            continue;
         }
     }
 
-    const char* PEFLoader::Path() { return fPath.Leak().CData(); }
+    return nullptr;
+}
+
+ErrorOr<VoidPtr> PEFLoader::LoadStart()
+{
+    if (auto sym = this->FindSymbol("__start", kPefCode); sym)
+        return ErrorOr<VoidPtr>(sym);
+
+    return ErrorOr<VoidPtr>(H_EXEC_ERROR);
+}
+
+bool PEFLoader::IsLoaded() noexcept
+{
+    return !fBad && fCachedBlob;
+}
+
+namespace Utils
+{
+bool execute_from_image(PEFLoader &exec) noexcept
+{
+    auto errOrStart = exec.LoadStart();
+
+    if (errOrStart.Error() != 0)
+        return false;
 
-    const char* PEFLoader::Format() { return "PEF"; }
+    Process proc(errOrStart.Leak().Leak());
+    Ref<Process> refProc = proc;
 
-    const char* PEFLoader::MIME() { return "application/x-exec"; }
+    return ProcessManager::Shared().Leak().Add(refProc);
+}
+} // namespace Utils
+
+const char *PEFLoader::Path()
+{
+    return fPath.Leak().CData();
+}
+
+const char *PEFLoader::Format()
+{
+    return "PEF";
+}
+
+const char *PEFLoader::MIME()
+{
+    return "application/x-exec";
+}
 } // namespace hCore
diff --git a/Private/Source/ProcessManager.cxx b/Private/Source/ProcessManager.cxx
index 4679daff..664a1c7c 100644
--- a/Private/Source/ProcessManager.cxx
+++ b/Private/Source/ProcessManager.cxx
@@ -25,6 +25,10 @@
 
 namespace hCore
 {
+/***********************************************************************************/
+/// Exit Code stuff
+/***********************************************************************************/
+
 static Int32 kExitCode = 0;
 
 const Int32 &rt_get_exit_code() noexcept
@@ -32,9 +36,11 @@ const Int32 &rt_get_exit_code() noexcept
     return kExitCode;
 }
 
+/***********************************************************************************/
+
 void Process::Crash()
 {
-    kcout << this->Name << ": Crashed.";
+    kcout << this->Name << ": Crashed\n";
     this->Exit(-1);
 }
 
@@ -43,6 +49,8 @@ void Process::Wake(const bool should_wakeup)
     this->Status = should_wakeup ? ProcessStatus::kRunning : ProcessStatus::kFrozen;
 }
 
+/***********************************************************************************/
+
 VoidPtr Process::New(const SizeT &sz)
 {
     if (this->FreeMemory < 1)
@@ -65,6 +73,8 @@ VoidPtr Process::New(const SizeT &sz)
     return nullptr;
 }
 
+/***********************************************************************************/
+
 /* @brief checks if runtime pointer is in region. */
 bool rt_in_pool_region(VoidPtr pool_ptr, VoidPtr pool, const SizeT &sz)
 {
@@ -122,6 +132,8 @@ const ProcessStatus &Process::GetStatus()
     return this->Status;
 }
 
+/***********************************************************************************/
+
 /**
 @brief Affinity is the time slot allowed for the process.
 */
diff --git a/Private/Source/RuntimeMain.cxx b/Private/Source/RuntimeMain.cxx
index 4b91bb5f..210a5c43 100644
--- a/Private/Source/RuntimeMain.cxx
+++ b/Private/Source/RuntimeMain.cxx
@@ -13,14 +13,15 @@
 #include <KernelKit/FileManager.hpp>
 #include <NewKit/Json.hpp>
 
-extern void (*__SYSTEM_INIT_END)();
-extern void (**init)();
+/// PRIVATE SYMBOLS EXPORTED BY GCC.
+extern "C" void (*__SYSTEM_FINI)();
+extern "C" void (**__SYSTEM_INIT)();
 
 extern "C" void RuntimeMain()
 {
-    for (hCore::SizeT index_init = 0UL; init[index_init] != __SYSTEM_INIT_END; ++index_init)
+    for (hCore::SizeT index_init = 0UL; __SYSTEM_INIT[index_init] != __SYSTEM_FINI; ++index_init)
     {
-        init[index_init]();
+        __SYSTEM_INIT[index_init]();
     }
 
     MUST_PASS(hCore::init_hal());
diff --git a/Private/Source/SharedObject.cxx b/Private/Source/SharedObject.cxx
index 154fe0ed..a6ccc224 100644
--- a/Private/Source/SharedObject.cxx
+++ b/Private/Source/SharedObject.cxx
@@ -1,41 +1,55 @@
-/* 
-* ======================================================== 
-* 
-* hCore 
-* Copyright 2024 Mahrouss Logic, all rights reserved.
-* 
-*  ========================================================
-*/
+/*
+ * ========================================================
+ *
+ * hCore
+ * Copyright 2024 Mahrouss Logic, all rights reserved.
+ *
+ *  ========================================================
+ */
 
 #include <KernelKit/DebugOutput.hpp>
+#include <KernelKit/PEF.hpp>
 #include <KernelKit/ProcessManager.hpp>
-#include <KernelKit/ThreadLocalStorage.hxx>
 #include <KernelKit/SharedObjectCore.hxx>
+#include <KernelKit/ThreadLocalStorage.hxx>
+#include <NewKit/Defines.hpp>
 
 using namespace hCore;
 
 /***********************************************************************************/
 
-extern "C" SharedObject* __LibMain(VoidPtr image)
+extern "C" SharedObject *__LibMain(VoidPtr image)
 {
     /***********************************************************************************/
     /* Allocate new library to be added to the lookup table. 						   */
     /***********************************************************************************/
 
-    SharedObject* library = hcore_tls_new_class<SharedObject>();
+    SharedObject *library = hcore_tls_new_class<SharedObject>();
 
     if (!library)
     {
-        kcout << "__LibMain: out of memory!\n";
+        kcout << "__LibMain: Out of Memory!\n";
         ProcessManager::Shared().Leak().GetCurrent().Leak().Crash();
+
         return nullptr;
     }
 
     library->Mount(hcore_tls_new_class<SharedObject::SharedObjectTraits>());
 
-    kcout << "__LibMain: Done allocate DSO.\n";
+    if (!library->Get())
+    {
+        kcout << "__LibMain: Out of Memory!\n";
+        ProcessManager::Shared().Leak().GetCurrent().Leak().Crash();
+
+        return nullptr;
+    }
+
+    library->Get()->fImageObject = ProcessManager::Shared().Leak().GetCurrent().Leak().Image;
+    library->Get()->fImageEntrypointOffset = library->Load<VoidPtr>(kPefStart);
+
+    kcout << "__LibMain: Done allocating Shared Library...\n";
 
     return library;
 }
 
-/***********************************************************************************/
\ No newline at end of file
+/***********************************************************************************/