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

Kernel: Working on EFI reimplementation.

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

1 files changed, 110 insertions, 92 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