kernel: mmap the blob to VMAddress in PEFCodeMgr, alongside other fixes regarding memory leaks.

Signed-off-by: Amlal <amlal@nekernel.org>

10 files changed, 75 insertions, 48 deletions

diff --git a/dev/kernel/HALKit/AMD64/HalPagingMgrAMD64.cc b/dev/kernel/HALKit/AMD64/HalPagingMgrAMD64.cc
index 7a3e776f..4681b5e5 100644
--- a/dev/kernel/HALKit/AMD64/HalPagingMgrAMD64.cc
+++ b/dev/kernel/HALKit/AMD64/HalPagingMgrAMD64.cc
@@ -40,13 +40,14 @@ STATIC Void mmi_page_status(Detail::PTE* pte) {
   NE_UNUSED(pte);
 
 #ifdef __NE_VERBOSE_BITMAP__
-  (Void)(kout << (pte->Present ? "Present" : "Not Present") << kendl);
-  (Void)(kout << (pte->Wr ? "W/R" : "Not W/R") << kendl);
-  (Void)(kout << (pte->Nx ? "NX" : "Not NX") << kendl);
-  (Void)(kout << (pte->User ? "User" : "Not User") << kendl);
-  (Void)(kout << (pte->Pcd ? "Not Cached" : "Cached") << kendl);
-  (Void)(kout << (pte->Accessed ? "Accessed" : "Not Accessed") << kendl);
-  (Void)(kout << (pte->ProtectionKey ? "Protected" : "Not Protected/PKU Disabled") << kendl);
+  (Void)(kout << "Flag: " << (pte->Present ? "Present" : "Not Present") << kendl);
+  (Void)(kout << "Flag: " << (pte->Wr ? "W/R" : "Not W/R") << kendl);
+  (Void)(kout << "Flag: " << (pte->Nx ? "NX" : "Not NX") << kendl);
+  (Void)(kout << "Flag: " << pte->User ? "User" : "Not User") << kendl);
+  (Void)(kout << "Flag: " << (pte->Pcd ? "Not Cached" : "Cached") << kendl);
+  (Void)(kout << "Flag: " << (pte->Accessed ? "Accessed" : "Not Accessed") << kendl);
+  (Void)(kout << "Flag: " << (pte->ProtectionKey ? "Protected" : "Not Protected/PKU Disabled")
+              << kendl);
   (Void)(kout << "Physical Address: " << hex_number(pte->PhysicalAddress) << kendl);
 #endif
 }
@@ -56,7 +57,7 @@ STATIC Void mmi_page_status(Detail::PTE* pte) {
 /// @param virt a valid virtual address.
 /// @return Physical address.
 /***********************************************************************************/
-UIntPtr hal_get_phys_address(VoidPtr virt) {
+UIntPtr mm_get_phys_address(VoidPtr virt) {
   const UInt64 kVMAddr         = (UInt64) virt;
   const UInt64 kMask9Bits      = 0x1FFULL;
   const UInt64 kPageOffsetMask = 0xFFFULL;
@@ -101,7 +102,7 @@ UIntPtr hal_get_phys_address(VoidPtr virt) {
 /// @brief clflush+mfence helper function.
 /***********************************************************************************/
 EXTERN_C Int32 mm_memory_fence(VoidPtr virtual_address) {
-  if (!virtual_address || !hal_get_phys_address(virtual_address)) return kErrorInvalidData;
+  if (!virtual_address || !mm_get_phys_address(virtual_address)) return kErrorInvalidData;
 
   asm volatile("clflush (%0)" : : "r"(virtual_address) : "memory");
   asm volatile("mfence" ::: "memory");
@@ -117,6 +118,8 @@ EXTERN_C Int32 mm_memory_fence(VoidPtr virtual_address) {
 /// @return Status code of page manipulation process.
 /***********************************************************************************/
 EXTERN_C Int32 mm_map_page(VoidPtr virtual_address, VoidPtr physical_address, UInt32 flags) {
+  if (physical_address == 0) return kErrorInvalidData;
+
   const UInt64     kVMAddr   = (UInt64) virtual_address;
   constexpr UInt64 kMask9    = 0x1FF;
   constexpr UInt64 kPageMask = 0xFFF;
diff --git a/dev/kernel/HALKit/AMD64/Processor.h b/dev/kernel/HALKit/AMD64/Processor.h
index d7d594d9..e1ce8718 100644
--- a/dev/kernel/HALKit/AMD64/Processor.h
+++ b/dev/kernel/HALKit/AMD64/Processor.h
@@ -179,7 +179,7 @@ inline Bool hal_has_msr() noexcept {
   return edx & (1 << 5);
 }
 
-UIntPtr hal_get_phys_address(VoidPtr virtual_address);
+UIntPtr mm_get_phys_address(VoidPtr virtual_address);
 
 /***********************************************************************************/
 /// @brief Get Model specific register inside core.
diff --git a/dev/kernel/HALKit/AMD64/Storage/AHCI+Generic.cc b/dev/kernel/HALKit/AMD64/Storage/AHCI+Generic.cc
index d09fd71a..eba2f892 100644
--- a/dev/kernel/HALKit/AMD64/Storage/AHCI+Generic.cc
+++ b/dev/kernel/HALKit/AMD64/Storage/AHCI+Generic.cc
@@ -324,7 +324,7 @@ STATIC Bool drv_init_command_structures_ahci() {
     return NO;
   }
 
-  UIntPtr clb_phys = HAL::hal_get_phys_address(clb_mem);
+  UIntPtr clb_phys = HAL::mm_get_phys_address(clb_mem);
 
   kSATAHba->Ports[kSATAIndex].Clb  = (UInt32) (clb_phys & 0xFFFFFFFF);
   kSATAHba->Ports[kSATAIndex].Clbu = (UInt32) (clb_phys >> 32);
@@ -344,7 +344,7 @@ STATIC Bool drv_init_command_structures_ahci() {
       return NO;
     }
 
-    UIntPtr ct_phys = HAL::hal_get_phys_address(ct_mem);
+    UIntPtr ct_phys = HAL::mm_get_phys_address(ct_mem);
 
     header[i].Ctba  = (UInt32) (ct_phys & 0xFFFFFFFF);
     header[i].Ctbau = (UInt32) (ct_phys >> 32);
diff --git a/dev/kernel/HALKit/ARM64/Processor.h b/dev/kernel/HALKit/ARM64/Processor.h
index 38902627..1d9d2af2 100644
--- a/dev/kernel/HALKit/ARM64/Processor.h
+++ b/dev/kernel/HALKit/ARM64/Processor.h
@@ -36,7 +36,7 @@ enum {
 /// @return Status code of page manip.
 EXTERN_C Int32 mm_map_page(VoidPtr virtual_address, VoidPtr physical_address, UInt32 flags);
 
-EXTERN_C UIntPtr hal_get_phys_address(VoidPtr virtual_address);
+EXTERN_C UIntPtr mm_get_phys_address(VoidPtr virtual_address);
 
 typedef UIntPtr    Reg;
 typedef Register64 Register;
diff --git a/dev/kernel/KernelKit/IPEFDylibObject.h b/dev/kernel/KernelKit/IPEFDylibObject.h
index 4031bd85..42ed1830 100644
--- a/dev/kernel/KernelKit/IPEFDylibObject.h
+++ b/dev/kernel/KernelKit/IPEFDylibObject.h
@@ -62,7 +62,7 @@ class IPEFDylibObject final NE_DYLIB_OBJECT {
     if (symbol_name == nullptr || *symbol_name == 0) return nullptr;
     if (len > kPathLen || len < 1) return nullptr;
 
-    auto ret = reinterpret_cast<SymbolType>(fLoader->FindSymbol(symbol_name, kind));
+    auto ret = reinterpret_cast<SymbolType>(fLoader->FindSymbol(symbol_name, kind).Leak().Leak());
 
     if (!ret) {
       if (kind == kPefCode) return (VoidPtr) &__zka_pure_call;
diff --git a/dev/kernel/KernelKit/LoaderInterface.h b/dev/kernel/KernelKit/LoaderInterface.h
index 42046a53..f6a1b7e9 100644
--- a/dev/kernel/KernelKit/LoaderInterface.h
+++ b/dev/kernel/KernelKit/LoaderInterface.h
@@ -27,6 +27,6 @@ class LoaderInterface {
   virtual _Output const Char*      MIME()                                                 = 0;
   virtual _Output const Char*      Path()                                                 = 0;
   virtual _Output ErrorOr<VoidPtr> FindStart()                                            = 0;
-  virtual _Output VoidPtr          FindSymbol(_Input const Char* name, _Input Int32 kind) = 0;
+  virtual _Output ErrorOr<VoidPtr> FindSymbol(_Input const Char* name, _Input Int32 kind) = 0;
 };
 }  // namespace Kernel
diff --git a/dev/kernel/KernelKit/PECodeMgr.h b/dev/kernel/KernelKit/PECodeMgr.h
index 860f3426..05a2674c 100644
--- a/dev/kernel/KernelKit/PECodeMgr.h
+++ b/dev/kernel/KernelKit/PECodeMgr.h
@@ -55,7 +55,7 @@ class PE32Loader : public LoaderInterface {
 
  public:
   ErrorOr<VoidPtr> FindStart() override;
-  VoidPtr          FindSymbol(const Char* name, Int32 kind) override;
+  ErrorOr<VoidPtr> FindSymbol(const Char* name, Int32 kind) override;
   ErrorOr<VoidPtr> GetBlob() override;
 
  public:
diff --git a/dev/kernel/KernelKit/PEF.h b/dev/kernel/KernelKit/PEF.h
index 03398b48..9381e491 100644
--- a/dev/kernel/KernelKit/PEF.h
+++ b/dev/kernel/KernelKit/PEF.h
@@ -98,7 +98,7 @@ typedef struct PEFCommandHeader final {
   UInt32  Flags;             /* container flags */
   UInt16  Kind;              /* container kind */
   UIntPtr Offset;            /* content offset */
-  UIntPtr  VMAddress;         /* VM offset */
+  UIntPtr VMAddress;         /* VM offset */
   SizeT   Size;              /* content Size */
 } PACKED PEFCommandHeader;
 
diff --git a/dev/kernel/KernelKit/PEFCodeMgr.h b/dev/kernel/KernelKit/PEFCodeMgr.h
index b3ca43d0..a637892f 100644
--- a/dev/kernel/KernelKit/PEFCodeMgr.h
+++ b/dev/kernel/KernelKit/PEFCodeMgr.h
@@ -42,7 +42,7 @@ class PEFLoader : public LoaderInterface {
 
  public:
   ErrorOr<VoidPtr> FindStart() override;
-  VoidPtr          FindSymbol(const Char* name, Int32 kind) override;
+  ErrorOr<VoidPtr> FindSymbol(const Char* name, Int32 kind) override;
   ErrorOr<VoidPtr> GetBlob() override;
 
  public:
diff --git a/dev/kernel/src/PEFCodeMgr.cc b/dev/kernel/src/PEFCodeMgr.cc
index 7a75f386..632d5baa 100644
--- a/dev/kernel/src/PEFCodeMgr.cc
+++ b/dev/kernel/src/PEFCodeMgr.cc
@@ -80,7 +80,7 @@ PEFLoader::PEFLoader(const Char* path) : fCachedBlob(nullptr), fFatBinary(false)
 
   if (fCachedBlob) mm_delete_heap(fCachedBlob);
 
-  kout << "PEFLoader: warn: Executable format error!\r";
+  kout << "PEFLoader: Warning: Executable format error!\r";
 
   fCachedBlob = nullptr;
 }
@@ -99,43 +99,44 @@ PEFLoader::~PEFLoader() {
 /// @param name name of symbol.
 /// @param kind kind of symbol we want.
 /***********************************************************************************/
-VoidPtr PEFLoader::FindSymbol(const Char* name, Int32 kind) {
-  if (!fCachedBlob || fBad || !name) return nullptr;
+ErrorOr<VoidPtr> PEFLoader::FindSymbol(const Char* name, Int32 kind) {
+  if (!fCachedBlob || fBad || !name) return ErrorOr<VoidPtr>{kErrorInvalidData};
 
   PEFContainer* container = reinterpret_cast<PEFContainer*>(fCachedBlob);
 
-  auto blob = fFile->Read(name, mib_cast(16));
+  auto blob = fFile->Read(name, sizeof(PEFCommandHeader));
 
   PEFCommandHeader* container_header = reinterpret_cast<PEFCommandHeader*>(blob);
 
-  constexpr auto cMangleCharacter  = '$';
-  const Char*    cContainerKinds[] = {".code64", ".data64", ".zero64", nullptr};
+  constexpr auto kMangleCharacter  = '$';
+  const Char*    kContainerKinds[] = {".code64", ".data64", ".zero64", nullptr};
 
   ErrorOr<KString> error_or_symbol;
 
   switch (kind) {
     case kPefCode: {
-      error_or_symbol = KStringBuilder::Construct(cContainerKinds[0]);  // code symbol.
+      error_or_symbol = KStringBuilder::Construct(kContainerKinds[0]);  // code symbol.
       break;
     }
     case kPefData: {
-      error_or_symbol = KStringBuilder::Construct(cContainerKinds[1]);  // data symbol.
+      error_or_symbol = KStringBuilder::Construct(kContainerKinds[1]);  // data symbol.
       break;
     }
     case kPefZero: {
-      error_or_symbol = KStringBuilder::Construct(cContainerKinds[2]);  // block starting symbol.
+      error_or_symbol = KStringBuilder::Construct(kContainerKinds[2]);  // block starting symbol.
       break;
     }
     default:
-      return nullptr;  // prevent that from the kernel's mode perspective, let that happen if it
-                       // were a user process.
+      return ErrorOr<VoidPtr>{kErrorInvalidData};
+      ;  // prevent that from the kernel's mode perspective, let that happen if it
+         // were a user process.
   }
 
   Char* unconst_symbol = const_cast<Char*>(name);
 
   for (SizeT i = 0UL; i < rt_string_len(unconst_symbol, kPefNameLen); ++i) {
     if (unconst_symbol[i] == ' ') {
-      unconst_symbol[i] = cMangleCharacter;
+      unconst_symbol[i] = kMangleCharacter;
     }
   }
 
@@ -147,7 +148,7 @@ VoidPtr PEFLoader::FindSymbol(const Char* name, Int32 kind) {
         if (container_header->Cpu != Detail::ldr_get_platform()) {
           if (!this->fFatBinary) {
             mm_delete_heap(blob);
-            return nullptr;
+            return ErrorOr<VoidPtr>{kErrorInvalidData};
           }
         }
 
@@ -157,27 +158,36 @@ VoidPtr PEFLoader::FindSymbol(const Char* name, Int32 kind) {
                        container_header->Size);
         mm_delete_heap(blob);
 
-        kout << "PEFLoader: INFO: Load stub: " << container_header->Name << "!\r";
+        kout << "PEFLoader: Information: Loaded stub: " << container_header->Name << "!\r";
 
-        return container_blob_value;
+        auto ret = HAL::mm_map_page((VoidPtr) container_header->VMAddress,
+                                    (VoidPtr) HAL::mm_get_phys_address(container_blob_value),
+                                    HAL::kMMFlagsPresent | HAL::kMMFlagsUser);
+
+        if (ret != kErrorSuccess) {
+          mm_delete_heap(container_blob_value);
+          return ErrorOr<VoidPtr>{kErrorInvalidData};
+        }
+
+        return ErrorOr<VoidPtr>{container_blob_value};
       }
     }
   }
 
   mm_delete_heap(blob);
-  return nullptr;
+  return ErrorOr<VoidPtr>{kErrorInvalidData};
 }
 
 /// @brief Finds the executable entrypoint.
 /// @return
 ErrorOr<VoidPtr> PEFLoader::FindStart() {
-  if (auto sym = this->FindSymbol(kPefStart, kPefCode); sym) return ErrorOr<VoidPtr>(sym);
+  if (auto sym = this->FindSymbol(kPefStart, kPefCode); sym) return sym;
 
   return ErrorOr<VoidPtr>(kErrorExecutable);
 }
 
 /// @brief Tells if the executable is loaded or not.
-/// @return
+/// @return Whether it's not bad and is cached.
 bool PEFLoader::IsLoaded() noexcept {
   return !fBad && fCachedBlob;
 }
@@ -188,17 +198,17 @@ const Char* PEFLoader::Path() {
 
 const Char* PEFLoader::AsString() {
 #ifdef __32x0__
-  return "32x0 PEF executable.";
+  return "32x0 PEF.";
 #elif defined(__64x0__)
-  return "64x0 PEF executable.";
+  return "64x0 PEF.";
 #elif defined(__x86_64__)
-  return "x86_64 PEF executable.";
+  return "x86_64 PEF.";
 #elif defined(__aarch64__)
-  return "AARCH64 PEF executable.";
+  return "AARCH64 PEF.";
 #elif defined(__powerpc64__)
-  return "POWER64 PEF executable.";
+  return "POWER64 PEF.";
 #else
-  return "???? PEF executable.";
+  return "???? PEF.";
 #endif  // __32x0__ || __64x0__ || __x86_64__ || __powerpc64__
 }
 
@@ -216,16 +226,30 @@ namespace Utils {
 
     if (errOrStart.Error() != kErrorSuccess) return kSchedInvalidPID;
 
-    auto id = UserProcessScheduler::The().Spawn(
-        reinterpret_cast<const Char*>(exec.FindSymbol(kPefNameSymbol, kPefData)),
-        errOrStart.Leak().Leak(), exec.GetBlob().Leak().Leak());
+    auto symname = exec.FindSymbol(kPefNameSymbol, kPefData);
+
+    if (!symname) {
+      symname = ErrorOr<VoidPtr>{(VoidPtr) rt_alloc_string("USER_PROCESS")};
+    }
+
+    auto id =
+        UserProcessScheduler::The().Spawn(reinterpret_cast<const Char*>(symname.Leak().Leak()),
+                                          errOrStart.Leak().Leak(), exec.GetBlob().Leak().Leak());
+
+    mm_delete_heap(symname.Leak().Leak());
 
     if (id != kSchedInvalidPID) {
+      auto stacksym = exec.FindSymbol(kPefStackSizeSymbol, kPefData);
+
+      if (!symname) {
+        stacksym = ErrorOr<VoidPtr>{(VoidPtr) new UIntPtr(mib_cast(16))};
+      }
+
       UserProcessScheduler::The().CurrentTeam().AsArray()[id].Kind = process_kind;
       UserProcessScheduler::The().CurrentTeam().AsArray()[id].StackSize =
-          *(UIntPtr*) exec.FindSymbol(kPefStackSizeSymbol, kPefData);
-      UserProcessScheduler::The().CurrentTeam().AsArray()[id].MemoryLimit =
-          *(UIntPtr*) exec.FindSymbol(kPefHeapSizeSymbol, kPefData);
+          *(UIntPtr*) stacksym.Leak().Leak();
+
+      mm_delete_heap(stacksym.Leak().Leak());
     }
 
     return id;