core: better memory configuration

src/core/address_space.cpp

@@ -26,7 +26,7 @@ asm(".zerofill GUEST_SYSTEM,GUEST_SYSTEM,__guest_system,0xFBFC00000");
 
 namespace Core {
 
-static constexpr size_t BackingSize = SCE_KERNEL_MAIN_DMEM_SIZE_PRO;
+static constexpr size_t BackingSize = SCE_KERNEL_TOTAL_MEM_PRO;
 
 #ifdef _WIN32
 

src/core/libraries/kernel/memory.h

@@ -6,9 +6,11 @@
 #include "common/bit_field.h"
 #include "common/types.h"
 
-constexpr u64 SCE_KERNEL_MAIN_DMEM_SIZE = 5056_MB; // ~ 5GB
+constexpr u64 SCE_KERNEL_TOTAL_MEM = 5248_MB;
-// TODO: Confirm this value on hardware.
+constexpr u64 SCE_KERNEL_TOTAL_MEM_PRO = 5888_MB;
-constexpr u64 SCE_KERNEL_MAIN_DMEM_SIZE_PRO = 5568_MB; // ~ 5.5GB
+
+constexpr u64 SCE_FLEXIBLE_MEMORY_BASE = 64_MB;
+constexpr u64 SCE_FLEXIBLE_MEMORY_SIZE = 512_MB;
 
 namespace Core::Loader {
 class SymbolsResolver;
@@ -129,10 +131,6 @@ s32 PS4_SYSV_ABI sceKernelMemoryPoolDecommit(void* addr, size_t len, int flags);
 
 int PS4_SYSV_ABI sceKernelMunmap(void* addr, size_t len);
 
-void* Malloc(size_t size);
-
-void Free(void* ptr);
-
 void RegisterMemory(Core::Loader::SymbolsResolver* sym);
 
 } // namespace Libraries::Kernel

src/core/libraries/np_trophy/np_trophy.cpp

@@ -498,7 +498,7 @@ int PS4_SYSV_ABI sceNpTrophyGetTrophyInfo(OrbisNpTrophyContext context, OrbisNpT
 s32 PS4_SYSV_ABI sceNpTrophyGetTrophyUnlockState(OrbisNpTrophyContext context,
                                                  OrbisNpTrophyHandle handle,
                                                  OrbisNpTrophyFlagArray* flags, u32* count) {
-    LOG_INFO(Lib_NpTrophy, "GetTrophyUnlockState called");
+    LOG_INFO(Lib_NpTrophy, "called");
 
     if (context == ORBIS_NP_TROPHY_INVALID_CONTEXT)
         return ORBIS_NP_TROPHY_ERROR_INVALID_CONTEXT;
@@ -519,8 +519,9 @@ s32 PS4_SYSV_ABI sceNpTrophyGetTrophyUnlockState(OrbisNpTrophyContext context,
     pugi::xml_parse_result result = doc.load_file(trophy_file.native().c_str());
 
     if (!result) {
-        LOG_ERROR(Lib_NpTrophy, "Failed to open trophy xml : {}", result.description());
+        LOG_ERROR(Lib_NpTrophy, "Failed to open trophy XML: {}", result.description());
-        return -1;
+        *count = 0;
+        return ORBIS_OK;
     }
 
     int num_trophies = 0;

src/core/linker.cpp

@@ -5,6 +5,7 @@
 #include "common/arch.h"
 #include "common/assert.h"
 #include "common/config.h"
+#include "common/elf_info.h"
 #include "common/logging/log.h"
 #include "common/path_util.h"
 #include "common/string_util.h"
@@ -65,21 +66,34 @@ void Linker::Execute() {
         Relocate(m.get());
     }
 
-    // Configure used flexible memory size.
+    // Configure the direct and flexible memory regions.
-    if (const auto* proc_param = GetProcParam()) {
+    u64 fmem_size = SCE_FLEXIBLE_MEMORY_SIZE;
-        if (proc_param->size >=
+    bool use_extended_mem1 = true, use_extended_mem2 = true;
-            offsetof(OrbisProcParam, mem_param) + sizeof(OrbisKernelMemParam*)) {
+
-            if (const auto* mem_param = proc_param->mem_param) {
+    const auto* proc_param = GetProcParam();
-                if (mem_param->size >=
+    ASSERT_MSG(proc_param);
-                    offsetof(OrbisKernelMemParam, flexible_memory_size) + sizeof(u64*)) {
+
-                    if (const auto* flexible_size = mem_param->flexible_memory_size) {
+    Core::OrbisKernelMemParam mem_param{};
-                        memory->SetupMemoryRegions(*flexible_size);
+    if (proc_param->size >= offsetof(OrbisProcParam, mem_param) + sizeof(OrbisKernelMemParam*)) {
-                    }
+        if (proc_param->mem_param) {
+            mem_param = *proc_param->mem_param;
+            if (mem_param.size >=
+                offsetof(OrbisKernelMemParam, flexible_memory_size) + sizeof(u64*)) {
+                if (const auto* flexible_size = mem_param.flexible_memory_size) {
+                    fmem_size = *flexible_size + SCE_FLEXIBLE_MEMORY_BASE;
                 }
             }
         }
     }
 
+    const u64 fw_ver = Common::ElfInfo::Instance().RawFirmwareVer();
+    if (fw_ver < Common::ElfInfo::FW_50) {
+        use_extended_mem1 = mem_param.extended_memory_1 ? *mem_param.extended_memory_1 : false;
+        use_extended_mem2 = mem_param.extended_memory_2 ? *mem_param.extended_memory_2 : false;
+    }
+
+    memory->SetupMemoryRegions(fmem_size, use_extended_mem1, use_extended_mem2);
+
     main_thread.Run([this, module](std::stop_token) {
         Common::SetCurrentThreadName("GAME_MainThread");
         LoadSharedLibraries();

src/core/memory.cpp

@@ -12,12 +12,7 @@
 
 namespace Core {
 
-constexpr u64 SCE_DEFAULT_FLEXIBLE_MEMORY_SIZE = 448_MB;
-
 MemoryManager::MemoryManager() {
-    // Set up the direct and flexible memory regions.
-    SetupMemoryRegions(SCE_DEFAULT_FLEXIBLE_MEMORY_SIZE);
-
     // Insert a virtual memory area that covers the entire area we manage.
     const VAddr system_managed_base = impl.SystemManagedVirtualBase();
     const size_t system_managed_size = impl.SystemManagedVirtualSize();
@@ -38,10 +33,17 @@ MemoryManager::MemoryManager() {
 
 MemoryManager::~MemoryManager() = default;
 
-void MemoryManager::SetupMemoryRegions(u64 flexible_size) {
+void MemoryManager::SetupMemoryRegions(u64 flexible_size, bool use_extended_mem1,
-    const auto total_size =
+                                       bool use_extended_mem2) {
-        Config::isNeoMode() ? SCE_KERNEL_MAIN_DMEM_SIZE_PRO : SCE_KERNEL_MAIN_DMEM_SIZE;
+    const bool is_neo = Config::isNeoMode();
-    total_flexible_size = flexible_size;
+    auto total_size = is_neo ? SCE_KERNEL_TOTAL_MEM_PRO : SCE_KERNEL_TOTAL_MEM;
+    if (!use_extended_mem1 && is_neo) {
+        total_size -= 256_MB;
+    }
+    if (!use_extended_mem2 && !is_neo) {
+        total_size -= 128_MB;
+    }
+    total_flexible_size = flexible_size - SCE_FLEXIBLE_MEMORY_BASE;
     total_direct_size = total_size - flexible_size;
 
     // Insert an area that covers direct memory physical block.

src/core/memory.h

@@ -166,7 +166,7 @@ public:
 
     bool TryWriteBacking(void* address, const void* data, u32 num_bytes);
 
-    void SetupMemoryRegions(u64 flexible_size);
+    void SetupMemoryRegions(u64 flexible_size, bool use_extended_mem1, bool use_extended_mem2);
 
     PAddr PoolExpand(PAddr search_start, PAddr search_end, size_t size, u64 alignment);