read only sdk version this way

Author: roamic

src/core/libraries/kernel/process.cpp

@@ -36,12 +36,10 @@ s32 PS4_SYSV_ABI sceKernelGetMainSocId() {
 }
 
 s32 PS4_SYSV_ABI sceKernelGetCompiledSdkVersion(s32* ver) {
-    auto* param = Core::Linker::GetProcParam();
-    constexpr u64 min_size = offsetof(Core::OrbisProcParam, sdk_version) + sizeof(u64);
-    if (!param || param->size < min_size || param->sdk_version == 0) {
+    if (!ver) {
         return ORBIS_KERNEL_ERROR_EINVAL;
     }
-    *ver = param->sdk_version;
+    *ver = Core::Linker::GetCompiledSdkVersion();
     return ORBIS_OK;
 }
 
@@ -65,7 +63,8 @@ s32 PS4_SYSV_ABI sceKernelGetCurrentCpu() {
 }
 
 void* PS4_SYSV_ABI sceKernelGetProcParam() {
-    return Core::Linker::GetProcParam();
+    auto* linker = Common::Singleton<Core::Linker>::Instance();
+    return linker->GetProcParam();
 }
 
 s32 PS4_SYSV_ABI sceKernelLoadStartModule(const char* moduleFileName, u64 args, const void* argp,

src/core/linker.cpp

@@ -51,7 +51,7 @@ static PS4_SYSV_ABI void* RunMainEntry [[noreturn]] (EntryParams* params) {
 }
 #endif
 
-OrbisProcParam Linker::s_proc_param{};
+s32 Linker::s_compiled_sdk_version{};
 
 Linker::Linker() : memory{Memory::Instance()} {}
 
@@ -182,7 +182,7 @@ s32 Linker::LoadAndStartModule(const std::filesystem::path& path, u64 args, cons
     }
 
     // Retrieve and verify proc param according to libkernel.
-    auto* param = GetProcParam();
+    auto* param = module->GetProcParam<OrbisProcParam*>();
     ASSERT_MSG(!param || param->size >= 0x18, "Invalid module param size: {}", param->size);
     s32 ret = module->Start(args, argp, param);
     if (pRes) {
@@ -450,7 +450,7 @@ void Linker::DebugDump() {
     }
 }
 
-void Linker::InitializeProcParams(const std::filesystem::path& file) {
+void Linker::ReadCompiledSdkVersion(const std::filesystem::path& file) {
     Core::Loader::Elf elf;
     elf.Open(file);
     if (!elf.IsElfFile()) {
@@ -462,7 +462,9 @@ void Linker::InitializeProcParams(const std::filesystem::path& file) {
 
     if (it != elf_pheader.end()) {
         // Initialize Proc Param in Linker
-        elf.LoadSegment(u64(Core::Linker::GetProcParam()), it->p_offset, it->p_filesz);
+        Core::OrbisProcParam param{};
+        elf.LoadSegment(u64(&param), it->p_offset, it->p_filesz);
+        s_compiled_sdk_version = param.sdk_version;
     }
 }
 

src/core/linker.h

@@ -78,8 +78,12 @@ class Linker {
         return m_hle_symbols;
     }
 
-    static OrbisProcParam* GetProcParam() {
-        return &s_proc_param;
+    static s32 GetCompiledSdkVersion() {
+        return s_compiled_sdk_version;
+    }
+
+    OrbisProcParam* GetProcParam() {
+        return m_modules[0]->GetProcParam<OrbisProcParam*>();
     }
 
     Module* GetModule(s32 index) const {
@@ -156,7 +160,7 @@ class Linker {
     void Execute(const std::vector<std::string>& args = {});
     void DebugDump();
 
-    static void InitializeProcParams(const std::filesystem::path& elf);
+    static void ReadCompiledSdkVersion(const std::filesystem::path& elf);
 
 private:
     const Module* FindExportedModule(const ModuleInfo& m, const LibraryInfo& l);
@@ -172,7 +176,7 @@ class Linker {
     std::vector<std::unique_ptr<Module>> m_modules;
     Loader::SymbolsResolver m_hle_symbols{};
 
-    static OrbisProcParam s_proc_param;
+    static s32 s_compiled_sdk_version;
 };
 
 } // namespace Core

src/core/module.cpp

@@ -199,6 +199,9 @@ void Module::LoadModuleToMemory(u32& max_tls_index) {
             LOG_INFO(Core_Linker, "TLS virtual address = {:#x}", tls.image_virtual_addr);
             LOG_INFO(Core_Linker, "TLS image size      = {}", tls.image_size);
             break;
+        case PT_SCE_PROCPARAM:
+            proc_param_virtual_addr = elf_pheader[i].p_vaddr + base_virtual_addr;
+            break;
         case PT_GNU_EH_FRAME: {
             eh_frame_hdr_addr = elf_pheader[i].p_vaddr;
             eh_frame_hdr_size = elf_pheader[i].p_memsz;

src/core/module.h

@@ -164,6 +164,11 @@ class Module {
         return elf.IsSharedLib();
     }
 
+    template <typename T = VAddr>
+    T GetProcParam() const noexcept {
+        return reinterpret_cast<T>(proc_param_virtual_addr);
+    }
+
     std::span<const ModuleInfo> GetImportModules() const {
         return dynamic_info.import_modules;
     }
@@ -215,6 +220,7 @@ class Module {
     Loader::Elf elf;
     u64 aligned_base_size{};
     VAddr base_virtual_addr{};
+    VAddr proc_param_virtual_addr{};
     VAddr eh_frame_hdr_addr{};
     VAddr eh_frame_addr{};
     u32 eh_frame_hdr_size{};

src/emulator.cpp

@@ -173,7 +173,7 @@ void Emulator::Run(std::filesystem::path file, std::vector<std::string> args,
 
     auto guest_eboot_path = "/app0/" + eboot_name.generic_string();
     const auto eboot_path = mnt->GetHostPath(guest_eboot_path);
-    Linker::InitializeProcParams(eboot_path);
+    Linker::ReadCompiledSdkVersion(eboot_path);
 
     const auto pic1_path = mnt->GetHostPath("/app0/sce_sys/pic1.png");
     if (std::filesystem::exists(pic1_path)) {
@@ -244,8 +244,8 @@ void Emulator::Run(std::filesystem::path file, std::vector<std::string> args,
     if (param_sfo_exists) {
         LOG_INFO(Loader, "Game id: {} Title: {}", id, title);
         LOG_INFO(Loader, "Fw: {:#x} App Version: {}", fw_version, app_version);
-        LOG_INFO(Loader, "params.sfo SDK version: {:#x}", sdk_version);
-        LOG_INFO(Loader, "eboot SDK version: {:#x}", Linker::GetProcParam()->sdk_version);
+        LOG_INFO(Loader, "param.sfo SDK version: {:#x}", sdk_version);
+        LOG_INFO(Loader, "eboot SDK version: {:#x}", Linker::GetCompiledSdkVersion());
         LOG_INFO(Loader, "PSVR Supported: {}", (bool)psf_attributes.support_ps_vr.Value());
         LOG_INFO(Loader, "PSVR Required: {}", (bool)psf_attributes.require_ps_vr.Value());
     }