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

Kernel: Working on EFI reimplementation.

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

14 files changed, 460 insertions, 223 deletions

diff --git a/Private/EFIKit/EFI.hxx b/Private/EFIKit/EFI.hxx
new file mode 100644
index 00000000..4bc9311f
--- /dev/null
+++ b/Private/EFIKit/EFI.hxx
@@ -0,0 +1,58 @@
+/*
+ *	========================================================
+ *
+ *	h-core
+ * 	Copyright 2024, Mahrouss Logic, all rights reserved.
+ *
+ * 	========================================================
+ */
+
+#pragma once
+
+#include <NewKit/Defines.hpp>
+
+using namespace hCore;
+
+typedef struct EfiTableHeader
+{
+    UInt64 signature;
+    UInt32 revision;
+    UInt32 headerSize;
+    UInt32 crc32;
+    UInt32 reserved;
+} EfiTableHeader;
+
+struct EfiSimpleTextOutputProtocol;
+
+typedef UInt64 (*EfiTextString)(struct EfiSimpleTextOutputProtocol *self, Int16 *string);
+
+typedef struct EfiSimpleTextOutputProtocol
+{
+    UInt64 reset;
+    EfiTextString output_string;
+    UInt64 test_string;
+    UInt64 query_mode;
+    UInt64 set_mode;
+    UInt64 set_attribute;
+    UInt64 clear_screen;
+    UInt64 set_cursor_position;
+    UInt64 enable_cursor;
+    UInt64 mode;
+} EfiSimpleTextOutputProtocol;
+
+typedef struct EfiSystemTable
+{
+    EfiTableHeader hdr;
+    Int16 *firmwareVendor;
+    UInt32 firmwareRevision;
+    VoidPtr consoleInHandle;
+    UInt64 conIn;
+    VoidPtr consoleOutHandle;
+    EfiSimpleTextOutputProtocol *conOut;
+    VoidPtr standardErrorHandle;
+    UInt64 stdErr;
+    UInt64 runtimeServices;
+    UInt64 bootServices;
+    UInt64 numberOfTableEntries;
+    UInt64 configurationTable;
+} EfiSystemTable;
diff --git a/Private/EFIKit/EPM.hxx b/Private/EFIKit/EPM.hxx
new file mode 100644
index 00000000..07de7d7c
--- /dev/null
+++ b/Private/EFIKit/EPM.hxx
@@ -0,0 +1,87 @@
+/*
+ *	========================================================
+ *
+ *	h-core
+ * 	Copyright 2024, Mahrouss Logic, all rights reserved.
+ *
+ * 	========================================================
+ */
+
+#ifndef __PARTITION_MAP__
+#define __PARTITION_MAP__
+
+inline constexpr int kUUIDLen = 37;
+
+/* the first 512 > x > 1024 bytes of a disk contains this headers. */
+
+/**
+ * @brief The EPM bootloader block.
+ * boot code info
+ */
+struct __attribute__((packed)) BootBlock
+{
+    char magic[4];
+    char name[32];
+    char uuid[kUUIDLen];
+    int version;
+    long long int num_blocks;
+    long long int sector_sz;
+    long long int sector_start;
+};
+
+/**
+ * @brief The EPM partition block.
+ * used to explain a partition inside a media.
+ */
+struct __attribute__((packed)) PartitionBlock
+{
+    char name[32];
+    int magic;
+    long long int sector_end;
+    long long int sector_sz;
+    long long int sector_start;
+    short type;
+    int version;
+    char fs[16]; /* ffs_2 */
+};
+
+/* @brief AMD64 magic for EPM */
+#define kMagic86 "EPMAM"
+
+/* @brief RISC-V magic for EPM */
+#define kMagicRISCV "EPMRV"
+
+/* @brief ARM magic for EPM */
+#define kMagicARM "EPMAR"
+
+/* @brief 64x0 magic for EPM */
+#define kMagic64k "EPM64"
+
+/* @brief 32x0 magic for EPM */
+#define kMagic32k "EPM32"
+
+#define kMaxBlks 128
+
+//! version types.
+//! use in boot block version field.
+
+enum
+{
+    kEPMMpUx = 0xcf,
+    kEPMLinux = 0x8f,
+    kEPMBSD = 0x9f,
+    kEPMHCore = 0x1f,
+};
+
+/// END SPECS
+
+typedef struct BootBlock BootBlockType;
+typedef struct PartitionBlock PartitionBlockType;
+
+#ifdef __x86_64__
+#define kMag kMagic86
+#else
+#define kMag "EPM??"
+#endif
+
+#endif // ifndef __PARTITION_MAP__
diff --git a/Private/HALKit/AMD64/ACPIManagerAMD64.cpp b/Private/HALKit/AMD64/ACPIManagerAMD64.cpp
index 2e5bf705..0f5e6f68 100644
--- a/Private/HALKit/AMD64/ACPIManagerAMD64.cpp
+++ b/Private/HALKit/AMD64/ACPIManagerAMD64.cpp
@@ -14,74 +14,79 @@
 
 namespace hCore
 {
-    ACPIManager::ACPIManager(voidPtr rsdPtr)
-        : m_Rsdp(rsdPtr), m_Entries(0)
-    {
-        RSDP* _rsdPtr = reinterpret_cast<RSDP*>(this->m_Rsdp);
-
-        MUST_PASS(_rsdPtr);
-        MUST_PASS(_rsdPtr->Revision >= 2);
-    }
+ACPIManager::ACPIManager(voidPtr rsdPtr) : m_Rsdp(rsdPtr), m_Entries(0)
+{
+    RSDP *_rsdPtr = reinterpret_cast<RSDP *>(this->m_Rsdp);
 
-    void ACPIManager::Shutdown() {}
-    void ACPIManager::Reset() {}
+    MUST_PASS(_rsdPtr);
+    MUST_PASS(_rsdPtr->Revision >= 2);
+}
 
-    ErrorOr <voidPtr> ACPIManager::Find(const char *signature)
-    {
-        MUST_PASS(m_Rsdp);
+void ACPIManager::Shutdown()
+{
+}
+void ACPIManager::Reset()
+{
+}
 
-        if (!signature)
-            return ErrorOr<voidPtr>{-2};
+ErrorOr<voidPtr> ACPIManager::Find(const char *signature)
+{
+    MUST_PASS(m_Rsdp);
 
-        if (*signature == 0)
-            return ErrorOr<voidPtr>{-3};
+    if (!signature)
+        return ErrorOr<voidPtr>{-2};
 
-        RSDP *rsdPtr = reinterpret_cast<RSDP*>(this->m_Rsdp);
+    if (*signature == 0)
+        return ErrorOr<voidPtr>{-3};
 
-        auto xsdt = rsdPtr->XsdtAddress;
-        SizeT num = (rsdPtr->Length + sizeof(SDT)) / 8;
+    RSDP *rsdPtr = reinterpret_cast<RSDP *>(this->m_Rsdp);
 
-        for (Size index = 0; index < num; ++index)
-        {
-            SDT *sdt = reinterpret_cast<SDT*>(xsdt + sizeof(SDT) + index * 8);
+    auto xsdt = rsdPtr->XsdtAddress;
+    SizeT num = (rsdPtr->Length + sizeof(SDT)) / 8;
 
-            if (!Checksum(sdt->Signature, 4))
-                panic(RUNTIME_CHECK_ACPI);
+    for (Size index = 0; index < num; ++index)
+    {
+        SDT *sdt = reinterpret_cast<SDT *>(xsdt + sizeof(SDT) + index * 8);
 
-            if (StringBuilder::Equals(const_cast<const char*>(sdt->Signature), signature))
-                return ErrorOr<voidPtr>(reinterpret_cast<voidPtr>(sdt));
-        }
+        if (!Checksum(sdt->Signature, 4))
+            panic(RUNTIME_CHECK_ACPI);
 
-        return ErrorOr<voidPtr>{-1};
+        if (StringBuilder::Equals(const_cast<const char *>(sdt->Signature), signature))
+            return ErrorOr<voidPtr>(reinterpret_cast<voidPtr>(sdt));
     }
 
-    bool ACPIManager::Checksum(const char *checksum, SSizeT len)
-    {
-        if (len == 0)
-            return -1;
+    return ErrorOr<voidPtr>{-1};
+}
 
-        char chr = 0;
+bool ACPIManager::Checksum(const char *checksum, SSizeT len)
+{
+    if (len == 0)
+        return -1;
 
-        for (int index = 0; index < len; ++index)
-        {
-            chr += checksum[index];
-        }
+    char chr = 0;
 
-        return chr == 0;
-    }
-
-    void rt_shutdown_acpi_qemu_20(void)
+    for (int index = 0; index < len; ++index)
     {
-        HAL::out16(0xb004, 0x2000);
+        chr += checksum[index];
     }
 
-    void rt_shutdown_acpi_qemu_30_plus(void)
-    {
-        HAL::out16(0x604, 0x2000);
-    }
+    return chr == 0;
+}
 
-    void rt_shutdown_acpi_virtualbox(void)
-    {
-        HAL::out16(0x4004, 0x3400);
-    }
+void rt_shutdown_acpi_qemu_20(void)
+{
+    HAL::out16(0xb004, 0x2000);
+}
+
+void rt_shutdown_acpi_qemu_30_plus(void)
+{
+    HAL::out16(0x604, 0x2000);
+}
+
+void rt_shutdown_acpi_virtualbox(void)
+{
+    HAL::out16(0x4004, 0x3400);
+}
+
+/// you'll have to parse the MADT otherwise!
 } // namespace hCore
diff --git a/Private/HALKit/AMD64/StartSequence.asm b/Private/HALKit/AMD64/StartSequence.asm
index 533db858..45bd1656 100644
--- a/Private/HALKit/AMD64/StartSequence.asm
+++ b/Private/HALKit/AMD64/StartSequence.asm
@@ -10,6 +10,7 @@
 [bits 64]
 [global Main]
 [extern RuntimeMain]
+[extern __SYSTEM_STACK_END]
 
 section .text
 
@@ -30,5 +31,6 @@ L0:
     jmp $
 
 MainBIOS:
-    cli hlt
+    cli
+    hlt
     jmp $
diff --git a/Private/KernelKit/CodeManager.hpp b/Private/KernelKit/CodeManager.hpp
index 5aa35a5b..66c8ca45 100644
--- a/Private/KernelKit/CodeManager.hpp
+++ b/Private/KernelKit/CodeManager.hpp
@@ -10,6 +10,7 @@
 #ifndef _INC_CODE_MANAGER_
 #define _INC_CODE_MANAGER_
 
+#include "NewKit/Defines.hpp"
 #include <KernelKit/PEF.hpp>
 #include <NewKit/ErrorOr.hpp>
 #include <NewKit/String.hpp>
@@ -26,6 +27,7 @@ class PEFLoader : public Loader
     explicit PEFLoader() = delete;
 
   public:
+    explicit PEFLoader(const VoidPtr blob);
     explicit PEFLoader(const char *path);
     ~PEFLoader() override;
 
diff --git a/Private/KernelKit/ProcessManager.hpp b/Private/KernelKit/ProcessManager.hpp
index cc96a18c..8f3e04a5 100644
--- a/Private/KernelKit/ProcessManager.hpp
+++ b/Private/KernelKit/ProcessManager.hpp
@@ -123,7 +123,7 @@ class Process final
   public:
     void AssignStart(UIntPtr &imageStart) noexcept;
 
-  private:
+  public:
     Char Name[kProcessLen] = {"hCore Process"};
     ProcessSubsystem SubSystem;
     ProcessSelector Selector;
diff --git a/Private/KernelKit/SharedObjectCore.hxx b/Private/KernelKit/SharedObjectCore.hxx
index 94b0ead2..07b261d0 100644
--- a/Private/KernelKit/SharedObjectCore.hxx
+++ b/Private/KernelKit/SharedObjectCore.hxx
@@ -10,48 +10,86 @@
 #ifndef __KERNELKIT_SHARED_OBJECT_CORE_HXX__
 #define __KERNELKIT_SHARED_OBJECT_CORE_HXX__
 
-#include <NewKit/Defines.hpp>
+#include "CodeManager.hpp"
+#include "PEF.hpp"
 #include <KernelKit/Loader.hpp>
+#include <NewKit/Defines.hpp>
 
 namespace hCore
 {
-	class SharedObject final
-	{
-	public:
-		struct SharedObjectTraits final
-		{
-			VoidPtr fImageObject;
-			VoidPtr fImageEntrypointOffset;
-		};
-
-	public:
-		explicit SharedObject() = default;
-		~SharedObject() = default;
-
-	public:
-		HCORE_COPY_DEFAULT(SharedObject);
-
-	private:
-		SharedObjectTraits* fMounted{ nullptr };
-
-	public:
-		SharedObjectTraits** GetAddressOf() { return &fMounted; }
-		SharedObjectTraits* Get() { return fMounted; }
-
-	public:
-		void Mount(SharedObjectTraits* to_mount) { fMounted = to_mount; }
-		void Unmount() { if (fMounted) fMounted = nullptr; };
-		
-		template <typename SymbolType>
-		SymbolType Load(const char* symbol_name);
-
-	};
-	
-	inline void hcore_pure_call(void)
-	{
-		// virtual placeholder.
-		return;	
-	}
+class SharedObject final
+{
+  public:
+    struct SharedObjectTraits final
+    {
+        VoidPtr fImageObject;
+        VoidPtr fImageEntrypointOffset;
+    };
+
+  public:
+    explicit SharedObject() = default;
+    ~SharedObject() = default;
+
+  public:
+    HCORE_COPY_DEFAULT(SharedObject);
+
+  private:
+    SharedObjectTraits *fMounted{nullptr};
+
+  public:
+    SharedObjectTraits **GetAddressOf()
+    {
+        return &fMounted;
+    }
+    SharedObjectTraits *Get()
+    {
+        return fMounted;
+    }
+
+  public:
+    void Mount(SharedObjectTraits *to_mount)
+    {
+        fMounted = to_mount;
+
+        if (fLoader && to_mount)
+        {
+            delete fLoader;
+            fLoader = nullptr;
+        }
+
+        if (!fLoader)
+        {
+            fLoader = new PEFLoader(fMounted->fImageObject);
+        }
+    }
+    void Unmount()
+    {
+        if (fMounted)
+            fMounted = nullptr;
+    };
+
+    template <typename SymbolType> SymbolType Load(const char *symbol_name)
+    {
+        auto ret = reinterpret_cast<SymbolType>(fLoader->FindSymbol(symbol_name, kPefCode));
+
+        if (!ret)
+            ret = reinterpret_cast<SymbolType>(fLoader->FindSymbol(symbol_name, kPefData));
+
+        if (!ret)
+            ret = reinterpret_cast<SymbolType>(fLoader->FindSymbol(symbol_name, kPefZero));
+
+        return ret;
+    }
+
+  private:
+    PEFLoader *fLoader{nullptr};
+};
+
+inline void hcore_pure_call(void)
+{
+    // virtual placeholder.
+    return;
 }
+} // namespace hCore
 
 #endif /* ifndef __KERNELKIT_SHARED_OBJECT_CORE_HXX__ */
diff --git a/Private/Linker/AMD64.ld b/Private/Linker/AMD64.ld
index f75c7533..39cb0076 100644
--- a/Private/Linker/AMD64.ld
+++ b/Private/Linker/AMD64.ld
@@ -1,6 +1,6 @@
 OUTPUT_FORMAT("elf64-x86-64")
 
-ENTRY(KMain)
+ENTRY(Main)
 
 PHDRS {
     null    PT_NULL    FLAGS(0) ;
@@ -19,8 +19,10 @@ SECTIONS {
     . += CONSTANT(MAXPAGESIZE);
 
      .init : {
+        __SYSTEM_INIT = .;
        	*(.initl)
-     } :init
+        __SYSTEM_FINI = .;
+     }
 
     __SYSTEM_INIT_END = .;
 
diff --git a/Private/NewBoot/Source/HEL/AMD64/PartitionMap.hxx b/Private/NewBoot/Source/HEL/AMD64/PartitionMap.hxx
index 69914b36..9dcd967f 100644
--- a/Private/NewBoot/Source/HEL/AMD64/PartitionMap.hxx
+++ b/Private/NewBoot/Source/HEL/AMD64/PartitionMap.hxx
@@ -7,8 +7,8 @@
  * 	========================================================
  */
 
-#ifndef __PARTITION_MAP_H__
-#define __PARTITION_MAP_H__
+#ifndef __PARTITION_MAP__
+#define __PARTITION_MAP__
 
 #define UUID_LEN 37
 
@@ -18,7 +18,7 @@
  * @brief The EPM bootloader block.
  * boot code info
  */
-struct boot_block
+struct __attribute__((packed)) BootBlock
 {
     char magic[4];
     char name[32];
@@ -33,7 +33,7 @@ struct boot_block
  * @brief The EPM partition block.
  * used to explain a partition inside a media.
  */
-struct part_block
+struct __attribute__((packed)) PartitionBlock
 {
     char name[32];
     int magic;
@@ -45,28 +45,25 @@ struct part_block
     char fs[16]; /* ffs_2 */
 };
 
-typedef struct part_block part_block_t;
-typedef struct boot_block boot_block_t;
-
 /* @brief AMD64 magic for EPM */
-#define EPM_MAGIC_X86 "EPMAM"
+#define PM_MAGIC_X86 "EPMAM"
 
 /* @brief RISC-V magic for EPM */
-#define EPM_MAGIC_RV "EPMRV"
+#define PM_MAGIC_RV "EPMRV"
 
 /* @brief ARM magic for EPM */
-#define EPM_MAGIC_ARM "EPMAR"
+#define PM_MAGIC_ARM "EPMAR"
 
 /* @brief 64x0 magic for EPM */
-#define EPM_MAGIC_64x0 "EPM64"
+#define PM_MAGIC_64x0 "EPM64"
 
 /* @brief 32x0 magic for EPM */
-#define EPM_MAGIC_32x0 "EPM32"
+#define PM_MAGIC_32x0 "EPM32"
 
-#define EPM_MAX_BLKS 128
+#define PM_MAX_BLKS 128
 
-#define EPM_BOOT_BLK_SZ sizeof(struct boot_block)
-#define EPM_PART_BLK_SZ sizeof(struct part_block)
+#define PM_BOOT_BLK_SZ sizeof(struct boot_block)
+#define PM_PART_BLK_SZ sizeof(struct part_block)
 
 //! version types.
 //! use in boot block version field.
@@ -81,13 +78,13 @@ enum
 
 /// END SPECS
 
-typedef boot_block_t BootBlockType;
-typedef part_block_t PartitionBlockType;
+typedef struct BootBlock BootBlockType;
+typedef struct PartitionBlock PartitionBlockType;
 
 #ifdef __x86_64__
-#define PM_MAG EPM_MAGIC_X86
+#define PM_MAG PM_MAGIC_X86
 #else
 #define PM_MAG "?"
 #endif
 
-#endif // ifndef __PARTITION_MAP_H__
+#endif // ifndef __PARTITION_MAP__
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
+/***********************************************************************************/
diff --git a/Private/makefile b/Private/makefile
index a4a2ec01..8acbd5c3 100644
--- a/Private/makefile
+++ b/Private/makefile
@@ -23,6 +23,7 @@ kernel-build:
 		Source/Storage/*.cxx HALKit/AMD64/*.cxx HALKit/AMD64/*.cpp HALKit/AMD64/*.s
 	$(ASM) -f elf64 HALKit/AMD64/DebugManager.asm
 	$(ASM) -f elf64 HALKit/AMD64/SMPCoreManager.asm
+	$(ASM) -f elf64 HALKit/AMD64/StartSequence.asm
 	mv *.o HALKit/AMD64/*.o Obj/