Merge pull request #233 from shadps4-emu/miscFixes2

Misc Fixes
2024-07-05 09:36:01 +03:00 · 2024-07-05 09:36:01 +03:00 · 67af53fd58
parent 3f123bbce2 7ea87f69ea
commit 67af53fd58
17 changed files with 566 additions and 105 deletions
--- a/.gitmodules
+++ b/.gitmodules
@ -58,3 +58,6 @@
 [submodule "externals/tracy"]
 	path = externals/tracy
 	url = https://github.com/shadps4-emu/tracy.git
+[submodule "externals/hwinfo"]
+	path = externals/hwinfo
+	url = https://github.com/lfreist/hwinfo.git
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -544,7 +544,7 @@ endif()

 create_target_directory_groups(shadps4)

-target_link_libraries(shadps4 PRIVATE magic_enum::magic_enum fmt::fmt toml11::toml11 tsl::robin_map xbyak::xbyak Tracy::TracyClient)
+target_link_libraries(shadps4 PRIVATE magic_enum::magic_enum fmt::fmt toml11::toml11 tsl::robin_map xbyak::xbyak Tracy::TracyClient hwinfo::HWinfo)
 target_link_libraries(shadps4 PRIVATE Boost::headers GPUOpen::VulkanMemoryAllocator sirit Vulkan::Headers xxHash::xxhash Zydis::Zydis glslang::SPIRV glslang::glslang SDL3::SDL3)

 if (NOT ENABLE_QT_GUI)
--- a/externals/CMakeLists.txt
+++ b/externals/CMakeLists.txt
@ -140,3 +140,6 @@ option(TRACY_ON_DEMAND "" ON)
 option(TRACY_NO_FRAME_IMAGE "" ON)
 option(TRACY_FIBERS "" ON) # For AmdGpu frontend profiling
 add_subdirectory(tracy)
+
+# hwinfo
+add_subdirectory(hwinfo)
--- a/externals/hwinfo
+++ b/externals/hwinfo
@ -0,0 +1 @@
+Subproject commit 81ea6332fd4839890b1904f9668865145450f8da
--- a/src/core/file_sys/fs.cpp
+++ b/src/core/file_sys/fs.cpp
@ -20,7 +20,11 @@ void MntPoints::Mount(const std::filesystem::path& host_folder, const std::strin
    m_mnt_pairs.push_back(pair);
 }

-void MntPoints::Unmount(const std::string& path) {} // TODO!
+void MntPoints::Unmount(const std::filesystem::path& host_folder, const std::string& guest_folder) {
+    auto it = std::remove_if(m_mnt_pairs.begin(), m_mnt_pairs.end(),
+                             [&](const MntPair& pair) { return pair.guest_path == guest_folder; });
+    m_mnt_pairs.erase(it, m_mnt_pairs.end());
+}

 void MntPoints::UnmountAll() {
    std::scoped_lock lock{m_mutex};
--- a/src/core/file_sys/fs.h
+++ b/src/core/file_sys/fs.h
@ -22,7 +22,7 @@ public:
    virtual ~MntPoints() = default;

    void Mount(const std::filesystem::path& host_folder, const std::string& guest_folder);
-    void Unmount(const std::string& path);
+    void Unmount(const std::filesystem::path& host_folder, const std::string& guest_folder);
    void UnmountAll();
    std::string GetHostDirectory(const std::string& guest_directory);
    std::string GetHostFile(const std::string& guest_file);
--- a/src/core/libraries/app_content/app_content.cpp
+++ b/src/core/libraries/app_content/app_content.cpp
@ -52,7 +52,7 @@ int PS4_SYSV_ABI sceAppContentAddcontUnmount() {

 int PS4_SYSV_ABI sceAppContentAppParamGetInt(OrbisAppContentAppParamId paramId, s32* value) {
    if (value == nullptr)
-        return 0x80D90002;
+        return ORBIS_APP_CONTENT_ERROR_PARAMETER;
    auto* param_sfo = Common::Singleton<PSF>::Instance();
    switch (paramId) {
    case ORBIS_APP_CONTENT_APPPARAM_ID_SKU_FLAG:
@ -70,9 +70,18 @@ int PS4_SYSV_ABI sceAppContentAppParamGetInt(OrbisAppContentAppParamId paramId,
    case ORBIS_APP_CONTENT_APPPARAM_ID_USER_DEFINED_PARAM_4:
        *value = param_sfo->GetInteger("USER_DEFINED_PARAM_4");
        break;
+    default:
+        LOG_ERROR(Lib_AppContent, " paramId = {}, value = {} paramId is not valid", paramId,
+                  *value);
+        return ORBIS_APP_CONTENT_ERROR_PARAMETER;
    }
-    LOG_ERROR(Lib_AppContent, " paramId = {}, value = {}", paramId, *value);
-    return *value == -1 ? 0x80D90005 : ORBIS_OK;
+    if (*value == -1) {
+        LOG_ERROR(Lib_AppContent,
+                  " paramId = {}, value = {} value is not valid can't read param.sfo?", paramId,
+                  *value);
+        return ORBIS_APP_CONTENT_ERROR_PARAMETER;
+    }
+    return ORBIS_OK;
 }

 int PS4_SYSV_ABI sceAppContentAppParamGetString() {
@ -120,8 +129,11 @@ int PS4_SYSV_ABI sceAppContentGetAddcontInfo() {
    return ORBIS_OK;
 }

-int PS4_SYSV_ABI sceAppContentGetAddcontInfoList() {
-    LOG_ERROR(Lib_AppContent, "(STUBBED) called");
+int PS4_SYSV_ABI sceAppContentGetAddcontInfoList(u32 service_label,
+                                                 OrbisAppContentAddcontInfo* list, u32 list_num,
+                                                 u32* hit_num) {
+    *hit_num = 0;
+    LOG_ERROR(Lib_AppContent, "(DUMMY) called");
    return ORBIS_OK;
 }

--- a/src/core/libraries/app_content/app_content.h
+++ b/src/core/libraries/app_content/app_content.h
@ -31,22 +31,29 @@ struct OrbisAppContentBootParam {
 };

 typedef u32 OrbisAppContentTemporaryDataOption;
-constexpr int ORBIS_APP_CONTENT_MOUNTPOINT_DATA_MAXSIZE = 16;
-typedef struct OrbisAppContentMountPoint {

+constexpr int ORBIS_APP_CONTENT_MOUNTPOINT_DATA_MAXSIZE = 16;
+
+struct OrbisAppContentMountPoint {
    char data[ORBIS_APP_CONTENT_MOUNTPOINT_DATA_MAXSIZE];
-} OrbisAppContentMountPoint;
+};

 constexpr int ORBIS_APP_CONTENT_TEMPORARY_DATA_OPTION_NONE = 0;
 constexpr int ORBIS_APP_CONTENT_TEMPORARY_DATA_OPTION_FORMAT = (1 << 0);
 constexpr int ORBIS_NP_UNIFIED_ENTITLEMENT_LABEL_SIZE = 17;
-typedef struct OrbisNpUnifiedEntitlementLabel {

+struct OrbisNpUnifiedEntitlementLabel {
    char data[ORBIS_NP_UNIFIED_ENTITLEMENT_LABEL_SIZE];
-} OrbisNpUnifiedEntitlementLabel;
+    char padding[3];
+};

 typedef u32 OrbisAppContentAppParamId;

+struct OrbisAppContentAddcontInfo {
+    OrbisNpUnifiedEntitlementLabel entitlement_label;
+    u32 status;
+};
+
 int PS4_SYSV_ABI _Z5dummyv();
 int PS4_SYSV_ABI sceAppContentAddcontDelete();
 int PS4_SYSV_ABI sceAppContentAddcontEnqueueDownload();
@ -64,7 +71,9 @@ int PS4_SYSV_ABI sceAppContentDownloadDataFormat();
 int PS4_SYSV_ABI sceAppContentDownloadDataGetAvailableSpaceKb();
 int PS4_SYSV_ABI sceAppContentGetAddcontDownloadProgress();
 int PS4_SYSV_ABI sceAppContentGetAddcontInfo();
-int PS4_SYSV_ABI sceAppContentGetAddcontInfoList();
+int PS4_SYSV_ABI sceAppContentGetAddcontInfoList(u32 service_label,
+                                                 OrbisAppContentAddcontInfo* list, u32 list_num,
+                                                 u32* hit_num);
 int PS4_SYSV_ABI sceAppContentGetEntitlementKey();
 int PS4_SYSV_ABI sceAppContentGetRegion();
 int PS4_SYSV_ABI sceAppContentInitialize(const OrbisAppContentInitParam* initParam,
--- a/src/core/libraries/error_codes.h
+++ b/src/core/libraries/error_codes.h
@ -453,3 +453,6 @@ constexpr int ORBIS_NP_TROPHY_ERROR_INVALID_HANDLE = 0x80551608;
 constexpr int ORBIS_NP_TROPHY_ERROR_HANDLE_EXCEEDS_MAX = 0x80551624;
 constexpr int ORBIS_NP_TROPHY_ERROR_CONTEXT_ALREADY_EXISTS = 0x80551613;
 constexpr int ORBIS_NP_TROPHY_ERROR_CONTEXT_EXCEEDS_MAX = 0x80551622;
+
+// AppContent library
+constexpr int ORBIS_APP_CONTENT_ERROR_PARAMETER = 0x80D90002;
--- a/src/core/libraries/kernel/file_system.cpp
+++ b/src/core/libraries/kernel/file_system.cpp
@ -90,7 +90,11 @@ int PS4_SYSV_ABI sceKernelOpen(const char* path, int flags, u16 mode) {
        }
        if (!file->f.IsOpen()) {
            h->DeleteHandle(handle);
-            return SCE_KERNEL_ERROR_EACCES;
+            if (create) {
+                return ORBIS_KERNEL_ERROR_EACCES;
+            } else {
+                return ORBIS_KERNEL_ERROR_ENOENT;
+            }
        }
    }
    file->is_opened = true;
@ -227,7 +231,8 @@ int PS4_SYSV_ABI sceKernelMkdir(const char* path, u16 mode) {
        return SCE_KERNEL_ERROR_EEXIST;
    }

-    if (!std::filesystem::create_directory(dir_name)) {
+    // CUSA02456: path = /aotl after sceSaveDataMount(mode = 1)
+    if (dir_name.empty() || !std::filesystem::create_directory(dir_name)) {
        return SCE_KERNEL_ERROR_EIO;
    }

--- a/src/core/libraries/kernel/thread_management.cpp
+++ b/src/core/libraries/kernel/thread_management.cpp
@ -1292,6 +1292,19 @@ int PS4_SYSV_ABI scePthreadOnce(int* once_control, void (*init_routine)(void)) {
    UNREACHABLE();
 }

+int PS4_SYSV_ABI scePthreadGetthreadid() {
+    return (int)(size_t)g_pthread_self;
+}
+
+int PS4_SYSV_ABI scePthreadGetprio(ScePthread thread, int* prio) {
+    *prio = thread->prio;
+    return ORBIS_OK;
+}
+int PS4_SYSV_ABI scePthreadSetprio(ScePthread thread, int prio) {
+    thread->prio = prio;
+    return ORBIS_OK;
+}
+
 void pthreadSymbolsRegister(Core::Loader::SymbolsResolver* sym) {
    LIB_FUNCTION("lZzFeSxPl08", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_setcancelstate);
    LIB_FUNCTION("0TyVk4MSLt0", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_cond_init);
@ -1312,6 +1325,9 @@ void pthreadSymbolsRegister(Core::Loader::SymbolsResolver* sym) {
    LIB_FUNCTION("3kg7rT0NQIs", "libkernel", 1, "libkernel", 1, 1, scePthreadExit);
    LIB_FUNCTION("7Xl257M4VNI", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_equal);
    LIB_FUNCTION("h9CcP3J0oVM", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_join);
+    LIB_FUNCTION("EI-5-jlq2dE", "libkernel", 1, "libkernel", 1, 1, scePthreadGetthreadid);
+    LIB_FUNCTION("1tKyG7RlMJo", "libkernel", 1, "libkernel", 1, 1, scePthreadGetprio);
+    LIB_FUNCTION("W0Hpm2X0uPE", "libkernel", 1, "libkernel", 1, 1, scePthreadSetprio);

    LIB_FUNCTION("aI+OeCz8xrQ", "libkernel", 1, "libkernel", 1, 1, scePthreadSelf);
    LIB_FUNCTION("EotR8a3ASf4", "libkernel", 1, "libkernel", 1, 1, posix_pthread_self);
--- a/src/core/libraries/kernel/thread_management.h
+++ b/src/core/libraries/kernel/thread_management.h
@ -58,6 +58,7 @@ struct PthreadInternal {
    std::atomic_bool is_free;
    using Destructor = std::pair<OrbisPthreadKey, PthreadKeyDestructor>;
    std::vector<Destructor> key_destructors;
+    int prio;
 };

 struct PthreadAttrInternal {
--- a/src/core/libraries/save_data/error_codes.h
+++ b/src/core/libraries/save_data/error_codes.h
@ -3,6 +3,26 @@

 #pragma once

-constexpr int ORBIS_SAVE_DATA_ERROR_PARAMETER = 0x809f0000;
-constexpr int ORBIS_SAVE_DATA_ERROR_NOT_FOUND = 0x809f0008; // save data doesn't exist
-constexpr int ORBIS_SAVE_DATA_ERROR_EXISTS = 0x809f0007;    // save data directory,same name exists
+constexpr int ORBIS_SAVE_DATA_ERROR_PARAMETER = 0x809F0000;
+constexpr int ORBIS_SAVE_DATA_ERROR_NOT_INITIALIZED = 0x809F0001;
+constexpr int ORBIS_SAVE_DATA_ERROR_OUT_OF_MEMORY = 0x809F0002;
+constexpr int ORBIS_SAVE_DATA_ERROR_BUSY = 0x809F0003;
+constexpr int ORBIS_SAVE_DATA_ERROR_NOT_MOUNTED = 0x809F0004;
+constexpr int ORBIS_SAVE_DATA_ERROR_NO_PERMISSION = 0x809F0005;
+constexpr int ORBIS_SAVE_DATA_ERROR_FINGERPRINT_MISMATCH = 0x809F0006;
+constexpr int ORBIS_SAVE_DATA_ERROR_EXISTS = 0x809F0007;
+constexpr int ORBIS_SAVE_DATA_ERROR_NOT_FOUND = 0x809F0008;
+constexpr int ORBIS_SAVE_DATA_ERROR_NO_SPACE_FS = 0x809F000A;
+constexpr int ORBIS_SAVE_DATA_ERROR_INTERNAL = 0x809F000B;
+constexpr int ORBIS_SAVE_DATA_ERROR_MOUNT_FULL = 0x809F000C;
+constexpr int ORBIS_SAVE_DATA_ERROR_BAD_MOUNTED = 0x809F000D;
+constexpr int ORBIS_SAVE_DATA_ERROR_FILE_NOT_FOUND = 0x809F000E;
+constexpr int ORBIS_SAVE_DATA_ERROR_BROKEN = 0x809F000F;
+constexpr int ORBIS_SAVE_DATA_ERROR_INVALID_LOGIN_USER = 0x809F0011;
+constexpr int ORBIS_SAVE_DATA_ERROR_MEMORY_NOT_READY = 0x809F0012;
+constexpr int ORBIS_SAVE_DATA_ERROR_BACKUP_BUSY = 0x809F0013;
+constexpr int ORBIS_SAVE_DATA_ERROR_NOT_REGIST_CALLBACK = 0x809F0015;
+constexpr int ORBIS_SAVE_DATA_ERROR_BUSY_FOR_SAVING = 0x809F0016;
+constexpr int ORBIS_SAVE_DATA_ERROR_LIMITATION_OVER = 0x809F0017;
+constexpr int ORBIS_SAVE_DATA_ERROR_EVENT_BUSY = 0x809F0018;
+constexpr int ORBIS_SAVE_DATA_ERROR_PARAMSFO_TRANSFER_TITLE_ID_NOT_FOUND = 0x809F0019;
--- a/src/core/libraries/save_data/savedata.cpp
+++ b/src/core/libraries/save_data/savedata.cpp
@ -1,6 +1,8 @@
 // SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

+#include <span>
+#include <vector>
 #include <common/path_util.h>
 #include <common/singleton.h>
 #include <core/file_format/psf.h>
@ -13,8 +15,8 @@
 #include "error_codes.h"

 namespace Libraries::SaveData {
-
 static std::string g_mount_point = "/savedata0"; // temp mount point (todo)
+std::string game_serial;

 int PS4_SYSV_ABI sceSaveDataAbort() {
    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
@ -46,8 +48,14 @@ int PS4_SYSV_ABI sceSaveDataChangeInternal() {
    return ORBIS_OK;
 }

-int PS4_SYSV_ABI sceSaveDataCheckBackupData() {
-    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+int PS4_SYSV_ABI sceSaveDataCheckBackupData(const OrbisSaveDataCheckBackupData* check) {
+    auto* mnt = Common::Singleton<Core::FileSys::MntPoints>::Instance();
+    std::string mount_dir = mnt->GetHostFile(check->dirName->data);
+    if (!std::filesystem::exists(mount_dir)) {
+        return ORBIS_SAVE_DATA_ERROR_NOT_FOUND;
+    }
+    LOG_INFO(Lib_SaveData, "called = {}", mount_dir);
+
    return ORBIS_OK;
 }

@ -136,8 +144,14 @@ int PS4_SYSV_ABI sceSaveDataDebugTarget() {
    return ORBIS_OK;
 }

-int PS4_SYSV_ABI sceSaveDataDelete() {
-    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+int PS4_SYSV_ABI sceSaveDataDelete(const OrbisSaveDataDelete* del) {
+    const auto& mount_dir = Common::FS::GetUserPath(Common::FS::PathType::SaveDataDir) /
+                            std::to_string(1) / game_serial / std::string(del->dirName->data);
+    LOG_INFO(Lib_SaveData, "called: dirname = {}, mount_dir = {}", (char*)del->dirName->data,
+             mount_dir.string());
+    if (std::filesystem::exists(mount_dir) && std::filesystem::is_directory(mount_dir)) {
+        std::filesystem::remove_all(mount_dir);
+    }
    return ORBIS_OK;
 }

@ -161,8 +175,14 @@ int PS4_SYSV_ABI sceSaveDataDeleteUser() {
    return ORBIS_OK;
 }

-int PS4_SYSV_ABI sceSaveDataDirNameSearch() {
-    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+int PS4_SYSV_ABI sceSaveDataDirNameSearch(const OrbisSaveDataDirNameSearchCond* cond,
+                                          OrbisSaveDataDirNameSearchResult* result) {
+    if (cond == nullptr || cond->dirName == nullptr)
+        return ORBIS_SAVE_DATA_ERROR_PARAMETER;
+    LOG_ERROR(Lib_SaveData,
+              "TODO sceSaveDataDirNameSearch: search_dir_name = {}, key = {}, result = {}",
+              cond->dirName->data, (int)cond->key, (result->infos == nullptr));
+
    return ORBIS_OK;
 }

@ -226,8 +246,22 @@ int PS4_SYSV_ABI sceSaveDataGetEventInfo() {
    return ORBIS_OK;
 }

-int PS4_SYSV_ABI sceSaveDataGetEventResult() {
-    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+int PS4_SYSV_ABI sceSaveDataGetEventResult(const OrbisSaveDataEventParam* eventParam,
+                                           OrbisSaveDataEvent* event) {
+    LOG_INFO(Lib_SaveData, "called sceSaveDataGetEventResult : null = {}", (eventParam == nullptr));
+    if (eventParam == nullptr)
+        return ORBIS_SAVE_DATA_ERROR_PARAMETER;
+
+    const auto& mount_dir = Common::FS::GetUserPath(Common::FS::PathType::SaveDataDir) /
+                            std::to_string(1) / game_serial; // fix me
+
+    Common::FS::IOFile file(mount_dir / "param.txt", Common::FS::FileAccessMode::Read);
+    OrbisSaveDataParam* param = new OrbisSaveDataParam{};
+    file.ReadRaw<u8>(param, sizeof(OrbisSaveDataParam));
+
+    LOG_INFO(Lib_SaveData, "called");
+    event->userId = 1;
+
    return ORBIS_OK;
 }

@ -241,8 +275,11 @@ int PS4_SYSV_ABI sceSaveDataGetMountedSaveDataCount() {
    return ORBIS_OK;
 }

-int PS4_SYSV_ABI sceSaveDataGetMountInfo() {
-    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+int PS4_SYSV_ABI sceSaveDataGetMountInfo(const OrbisSaveDataMountPoint* mountPoint,
+                                         OrbisSaveDataMountInfo* info) {
+    LOG_INFO(Lib_SaveData, "called");
+    info->blocks = ORBIS_SAVE_DATA_BLOCKS_MAX;
+    info->freeBlocks = ORBIS_SAVE_DATA_BLOCKS_MAX;
    return ORBIS_OK;
 }

@ -261,13 +298,43 @@ int PS4_SYSV_ABI sceSaveDataGetSaveDataCount() {
    return ORBIS_OK;
 }

-int PS4_SYSV_ABI sceSaveDataGetSaveDataMemory() {
-    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+int PS4_SYSV_ABI sceSaveDataGetSaveDataMemory(const u32 userId, void* buf, const size_t bufSize,
+                                              const int64_t offset) {
+    const auto& mount_dir = Common::FS::GetUserPath(Common::FS::PathType::SaveDataDir) /
+                            std::to_string(userId) / game_serial / "save_mem1.sav";
+
+    Common::FS::IOFile file(mount_dir, Common::FS::FileAccessMode::Read);
+    if (!file.IsOpen()) {
+        return false;
+    }
+    file.Seek(offset);
+    size_t nbytes = file.ReadRaw<u8>(buf, bufSize);
+    LOG_INFO(Lib_SaveData, "called: bufSize = {}, offset = {}", bufSize, offset, nbytes);
+
    return ORBIS_OK;
 }

-int PS4_SYSV_ABI sceSaveDataGetSaveDataMemory2() {
-    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+int PS4_SYSV_ABI sceSaveDataGetSaveDataMemory2(OrbisSaveDataMemoryGet2* getParam) {
+    const auto& mount_dir = Common::FS::GetUserPath(Common::FS::PathType::SaveDataDir) /
+                            std::to_string(getParam->userId) / game_serial;
+    if (getParam == nullptr)
+        return ORBIS_SAVE_DATA_ERROR_PARAMETER;
+    if (getParam->data != nullptr) {
+        Common::FS::IOFile file(mount_dir / "save_mem2.sav", Common::FS::FileAccessMode::Read);
+        if (!file.IsOpen()) {
+            return false;
+        }
+        file.Seek(getParam->data->offset);
+        size_t nbytes = file.ReadRaw<u8>(getParam->data->buf, getParam->data->bufSize);
+        LOG_INFO(Lib_SaveData, "called: bufSize = {}, offset = {}", getParam->data->bufSize,
+                 getParam->data->offset);
+    }
+
+    if (getParam->param != nullptr) {
+        Common::FS::IOFile file1(mount_dir / "param.txt", Common::FS::FileAccessMode::Read);
+        size_t nbytes = file1.ReadRaw<u8>(getParam->param, sizeof(OrbisSaveDataParam));
+    }
+
    return ORBIS_OK;
 }

@ -297,17 +364,23 @@ int PS4_SYSV_ABI sceSaveDataGetUpdatedDataCount() {
 }

 int PS4_SYSV_ABI sceSaveDataInitialize() {
-    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    LOG_INFO(Lib_SaveData, "called");
+    static auto* param_sfo = Common::Singleton<PSF>::Instance();
+    game_serial = std::string(param_sfo->GetString("CONTENT_ID"), 7, 9);
    return ORBIS_OK;
 }

 int PS4_SYSV_ABI sceSaveDataInitialize2() {
-    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    LOG_INFO(Lib_SaveData, "called");
+    static auto* param_sfo = Common::Singleton<PSF>::Instance();
+    game_serial = std::string(param_sfo->GetString("CONTENT_ID"), 7, 9);
    return ORBIS_OK;
 }

 int PS4_SYSV_ABI sceSaveDataInitialize3() {
-    LOG_ERROR(Lib_SaveData, "(DUMMY) called");
+    LOG_INFO(Lib_SaveData, "called");
+    static auto* param_sfo = Common::Singleton<PSF>::Instance();
+    game_serial = std::string(param_sfo->GetString("CONTENT_ID"), 7, 9);
    return ORBIS_OK;
 }

@ -326,18 +399,24 @@ int PS4_SYSV_ABI sceSaveDataIsMounted() {
    return ORBIS_OK;
 }

-int PS4_SYSV_ABI sceSaveDataLoadIcon() {
-    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+int PS4_SYSV_ABI sceSaveDataLoadIcon(const OrbisSaveDataMountPoint* mountPoint,
+                                     OrbisSaveDataIcon* icon) {
+    auto* mnt = Common::Singleton<Core::FileSys::MntPoints>::Instance();
+    std::string mount_dir = mnt->GetHostFile(mountPoint->data);
+    LOG_INFO(Lib_SaveData, "called: dir = {}", mount_dir);
+
+    if (icon != nullptr) {
+        Common::FS::IOFile file(mount_dir + "/save_data.png", Common::FS::FileAccessMode::Read);
+        icon->bufSize = file.GetSize();
+        size_t nbytes = file.ReadRaw<u8>(icon->buf, icon->bufSize);
+    }
    return ORBIS_OK;
 }

-s32 saveDataMount(u32 user_id, std::string dir_name, u32 mount_mode,
+s32 saveDataMount(u32 user_id, char* dir_name, u32 mount_mode,
                  OrbisSaveDataMountResult* mount_result) {
-
-    auto* param_sfo = Common::Singleton<PSF>::Instance();
-    std::string id(param_sfo->GetString("CONTENT_ID"), 7, 9);
    const auto& mount_dir = Common::FS::GetUserPath(Common::FS::PathType::SaveDataDir) /
-                            std::to_string(user_id) / "savedata" / id / dir_name;
+                            std::to_string(user_id) / game_serial / dir_name;
    switch (mount_mode) {
    case ORBIS_SAVE_DATA_MOUNT_MODE_RDONLY:
    case ORBIS_SAVE_DATA_MOUNT_MODE_RDWR:
@ -347,12 +426,10 @@ s32 saveDataMount(u32 user_id, std::string dir_name, u32 mount_mode,
            return ORBIS_SAVE_DATA_ERROR_NOT_FOUND;
        }
        auto* mnt = Common::Singleton<Core::FileSys::MntPoints>::Instance();
-        mnt->Mount(mount_dir, g_mount_point);
-
        mount_result->mount_status = 0;
        std::strncpy(mount_result->mount_point.data, g_mount_point.c_str(), 16);
-        break;
-    }
+        mnt->Mount(mount_dir, mount_result->mount_point.data);
+    } break;
    case ORBIS_SAVE_DATA_MOUNT_MODE_CREATE:
    case ORBIS_SAVE_DATA_MOUNT_MODE_CREATE | ORBIS_SAVE_DATA_MOUNT_MODE_RDONLY:
    case ORBIS_SAVE_DATA_MOUNT_MODE_CREATE | ORBIS_SAVE_DATA_MOUNT_MODE_RDWR:
@ -362,16 +439,19 @@ s32 saveDataMount(u32 user_id, std::string dir_name, u32 mount_mode,
        ORBIS_SAVE_DATA_MOUNT_MODE_COPY_ICON:
    case ORBIS_SAVE_DATA_MOUNT_MODE_CREATE | ORBIS_SAVE_DATA_MOUNT_MODE_DESTRUCT_OFF |
        ORBIS_SAVE_DATA_MOUNT_MODE_COPY_ICON: {
+        auto* mnt = Common::Singleton<Core::FileSys::MntPoints>::Instance();
        if (std::filesystem::exists(mount_dir)) {
+            std::strncpy(mount_result->mount_point.data, g_mount_point.c_str(), 16);
+            mnt->Mount(mount_dir, mount_result->mount_point.data);
+            mount_result->required_blocks = 0;
+            mount_result->mount_status = 0;
            return ORBIS_SAVE_DATA_ERROR_EXISTS;
        }
-        std::filesystem::create_directories(mount_dir);
-
-        auto* mnt = Common::Singleton<Core::FileSys::MntPoints>::Instance();
-        mnt->Mount(mount_dir, g_mount_point);
-
+        if (std::filesystem::create_directories(mount_dir)) {
+            std::strncpy(mount_result->mount_point.data, g_mount_point.c_str(), 16);
+            mnt->Mount(mount_dir, mount_result->mount_point.data);
            mount_result->mount_status = 1;
-        strncpy(mount_result->mount_point.data, g_mount_point.c_str(), 16);
+        }
    } break;
    case ORBIS_SAVE_DATA_MOUNT_MODE_CREATE2 | ORBIS_SAVE_DATA_MOUNT_MODE_RDWR:
    case ORBIS_SAVE_DATA_MOUNT_MODE_CREATE2 | ORBIS_SAVE_DATA_MOUNT_MODE_RDWR |
@ -379,12 +459,10 @@ s32 saveDataMount(u32 user_id, std::string dir_name, u32 mount_mode,
        if (!std::filesystem::exists(mount_dir)) {
            std::filesystem::create_directories(mount_dir);
        }
-
        auto* mnt = Common::Singleton<Core::FileSys::MntPoints>::Instance();
-        mnt->Mount(mount_dir, g_mount_point);
-
+        std::strncpy(mount_result->mount_point.data, g_mount_point.c_str(), 16);
+        mnt->Mount(mount_dir, mount_result->mount_point.data);
        mount_result->mount_status = 1;
-        strncpy(mount_result->mount_point.data, g_mount_point.c_str(), 16);
    } break;
    default:
        UNREACHABLE();
@ -399,9 +477,9 @@ s32 PS4_SYSV_ABI sceSaveDataMount(const OrbisSaveDataMount* mount,
    if (mount == nullptr) {
        return ORBIS_SAVE_DATA_ERROR_PARAMETER;
    }
-    LOG_INFO(Lib_SaveData, "called: mount = {}, mode = {}, blocks = {}", mount->dir_name->data,
+    LOG_INFO(Lib_SaveData, "called: dirName = {}, mode = {}, blocks = {}", mount->dir_name->data,
             mount->mount_mode, mount->blocks);
-    return saveDataMount(mount->user_id, std::string(mount->dir_name->data), mount->mount_mode,
+    return saveDataMount(mount->user_id, (char*)mount->dir_name->data, mount->mount_mode,
                         mount_result);
 }

@ -410,9 +488,9 @@ s32 PS4_SYSV_ABI sceSaveDataMount2(const OrbisSaveDataMount2* mount,
    if (mount == nullptr) {
        return ORBIS_SAVE_DATA_ERROR_PARAMETER;
    }
-    LOG_INFO(Lib_SaveData, "called: mount = {}, mode = {}, blocks = {}", mount->dir_name->data,
+    LOG_INFO(Lib_SaveData, "called: dirName = {}, mode = {}, blocks = {}", mount->dir_name->data,
             mount->mount_mode, mount->blocks);
-    return saveDataMount(mount->user_id, std::string(mount->dir_name->data), mount->mount_mode,
+    return saveDataMount(mount->user_id, (char*)mount->dir_name->data, mount->mount_mode,
                         mount_result);
 }

@ -461,8 +539,16 @@ int PS4_SYSV_ABI sceSaveDataRestoreLoadSaveDataMemory() {
    return ORBIS_OK;
 }

-int PS4_SYSV_ABI sceSaveDataSaveIcon() {
-    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+int PS4_SYSV_ABI sceSaveDataSaveIcon(const OrbisSaveDataMountPoint* mountPoint,
+                                     const OrbisSaveDataIcon* icon) {
+    auto* mnt = Common::Singleton<Core::FileSys::MntPoints>::Instance();
+    std::string mount_dir = mnt->GetHostFile(mountPoint->data);
+    LOG_INFO(Lib_SaveData, "called = {}", mount_dir);
+
+    if (icon != nullptr) {
+        Common::FS::IOFile file(mount_dir + "/save_data.png", Common::FS::FileAccessMode::Write);
+        file.WriteRaw<u8>((void*)icon->buf, icon->bufSize);
+    }
    return ORBIS_OK;
 }

@ -476,8 +562,17 @@ int PS4_SYSV_ABI sceSaveDataSetEventInfo() {
    return ORBIS_OK;
 }

-int PS4_SYSV_ABI sceSaveDataSetParam() {
-    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+int PS4_SYSV_ABI sceSaveDataSetParam(const OrbisSaveDataMountPoint* mountPoint,
+                                     OrbisSaveDataParamType paramType, const void* paramBuf,
+                                     size_t paramBufSize) {
+    auto* mnt = Common::Singleton<Core::FileSys::MntPoints>::Instance();
+    std::string mount_dir = mnt->GetHostFile(mountPoint->data);
+    LOG_INFO(Lib_SaveData, "called = {}, mountPoint->data = {}", mount_dir, mountPoint->data);
+
+    if (paramBuf != nullptr) {
+        Common::FS::IOFile file(mount_dir + "/param.txt", Common::FS::FileAccessMode::Write);
+        file.WriteRaw<u8>((void*)paramBuf, paramBufSize);
+    }
    return ORBIS_OK;
 }

@ -486,23 +581,89 @@ int PS4_SYSV_ABI sceSaveDataSetSaveDataLibraryUser() {
    return ORBIS_OK;
 }

-int PS4_SYSV_ABI sceSaveDataSetSaveDataMemory() {
-    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+int PS4_SYSV_ABI sceSaveDataSetSaveDataMemory(const u32 userId, const void* buf,
+                                              const size_t bufSize, const int64_t offset) {
+    LOG_INFO(Lib_SaveData, "called");
+    const auto& mount_dir = Common::FS::GetUserPath(Common::FS::PathType::SaveDataDir) /
+                            std::to_string(userId) / game_serial / "save_mem1.sav";
+
+    Common::FS::IOFile file(mount_dir, Common::FS::FileAccessMode::Write);
+    file.Seek(offset);
+    file.WriteRaw<u8>((void*)buf, bufSize);
+
    return ORBIS_OK;
 }

-int PS4_SYSV_ABI sceSaveDataSetSaveDataMemory2() {
-    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+int PS4_SYSV_ABI sceSaveDataSetSaveDataMemory2(const OrbisSaveDataMemorySet2* setParam) {
+    LOG_INFO(Lib_SaveData, "called: dataNum = {}, slotId= {}", setParam->dataNum, setParam->slotId);
+    const auto& mount_dir = Common::FS::GetUserPath(Common::FS::PathType::SaveDataDir) /
+                            std::to_string(setParam->userId) / game_serial;
+    if (setParam->data != nullptr) {
+        Common::FS::IOFile file(mount_dir / "save_mem2.sav", Common::FS::FileAccessMode::Write);
+        if (!file.IsOpen())
+            return -1;
+        file.Seek(setParam->data->offset);
+        file.WriteRaw<u8>((void*)setParam->data->buf, setParam->data->bufSize);
+    }
+
+    if (setParam->param != nullptr) {
+        Common::FS::IOFile file(mount_dir / "param.txt", Common::FS::FileAccessMode::Write);
+        file.WriteRaw<u8>((void*)setParam->param, sizeof(OrbisSaveDataParam));
+    }
+
+    if (setParam->icon != nullptr) {
+        Common::FS::IOFile file(mount_dir / "save_icon.png", Common::FS::FileAccessMode::Write);
+        file.WriteRaw<u8>((void*)setParam->icon->buf, setParam->icon->bufSize);
+    }
+
    return ORBIS_OK;
 }

-int PS4_SYSV_ABI sceSaveDataSetupSaveDataMemory() {
-    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+int PS4_SYSV_ABI sceSaveDataSetupSaveDataMemory(u32 userId, size_t memorySize,
+                                                OrbisSaveDataParam* param) {
+
+    LOG_INFO(Lib_SaveData, "called:userId = {}, memorySize = {}", userId, memorySize);
+
+    const auto& mount_dir = Common::FS::GetUserPath(Common::FS::PathType::SaveDataDir) /
+                            std::to_string(userId) / game_serial;
+
+    if (std::filesystem::exists(mount_dir)) {
+        return ORBIS_SAVE_DATA_ERROR_EXISTS;
+    }
+    std::filesystem::create_directories(mount_dir);
+    std::vector<u8> buf(memorySize);
+    Common::FS::IOFile::WriteBytes(mount_dir / "save_mem1.sav", buf);
    return ORBIS_OK;
 }

-int PS4_SYSV_ABI sceSaveDataSetupSaveDataMemory2() {
-    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+int PS4_SYSV_ABI sceSaveDataSetupSaveDataMemory2(const OrbisSaveDataMemorySetup2* setupParam,
+                                                 OrbisSaveDataMemorySetupResult* result) {
+    if (setupParam == nullptr) {
+        return ORBIS_SAVE_DATA_ERROR_PARAMETER;
+    }
+    LOG_INFO(Lib_SaveData, "called");
+    // if (setupParam->option == 1) { // check this later.
+    const auto& mount_dir = Common::FS::GetUserPath(Common::FS::PathType::SaveDataDir) /
+                            std::to_string(setupParam->userId) / game_serial;
+    if (std::filesystem::exists(mount_dir) &&
+        std::filesystem::exists(mount_dir / "save_mem2.sav")) {
+        Common::FS::IOFile file(mount_dir / "save_mem2.sav", Common::FS::FileAccessMode::Read);
+        if (!file.IsOpen())
+            return -1;
+        // Bunny - CUSA07988 has a null result, having null result is checked and valid.
+        if (result != nullptr)
+            result->existedMemorySize = file.GetSize(); // Assign the saved data size.
+        //  do not return ORBIS_SAVE_DATA_ERROR_EXISTS, as it will not trigger
+        //  sceSaveDataGetSaveDataMemory2.
+    } else {
+        std::filesystem::create_directories(mount_dir);
+        std::vector<u8> buf(setupParam->memorySize); // check if > 0x1000000 (16.77mb) or x2?
+        Common::FS::IOFile::WriteBytes(mount_dir / "save_mem2.sav", buf);
+        std::vector<u8> paramBuf(sizeof(OrbisSaveDataParam));
+        Common::FS::IOFile::WriteBytes(mount_dir / "param.txt", paramBuf);
+        std::vector<u8> iconBuf(setupParam->iconMemorySize);
+        Common::FS::IOFile::WriteBytes(mount_dir / "save_icon.png", iconBuf);
+    }
    return ORBIS_OK;
 }

@ -521,8 +682,8 @@ int PS4_SYSV_ABI sceSaveDataSyncCloudList() {
    return ORBIS_OK;
 }

-int PS4_SYSV_ABI sceSaveDataSyncSaveDataMemory() {
-    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+int PS4_SYSV_ABI sceSaveDataSyncSaveDataMemory(OrbisSaveDataMemorySync* syncParam) {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called: option = {}", syncParam->option);
    return ORBIS_OK;
 }

@ -537,12 +698,16 @@ int PS4_SYSV_ABI sceSaveDataTransferringMount() {
 }

 s32 PS4_SYSV_ABI sceSaveDataUmount(const OrbisSaveDataMountPoint* mountPoint) {
-    LOG_INFO(Lib_SaveData, "mountPoint = {}", std::string(mountPoint->data));
    if (std::string(mountPoint->data).empty()) {
-        return ORBIS_SAVE_DATA_ERROR_PARAMETER;
+        return ORBIS_SAVE_DATA_ERROR_NOT_MOUNTED;
    }
+    const auto& mount_dir = Common::FS::GetUserPath(Common::FS::PathType::SaveDataDir) /
+                            std::to_string(1) / game_serial / mountPoint->data;
    auto* mnt = Common::Singleton<Core::FileSys::MntPoints>::Instance();
-    mnt->Unmount(std::string(mountPoint->data));
+
+    mnt->Unmount(mount_dir, mountPoint->data);
+    LOG_INFO(Lib_SaveData, "mountPoint = {}", std::string(mountPoint->data));
+
    return ORBIS_OK;
 }

@ -551,8 +716,27 @@ int PS4_SYSV_ABI sceSaveDataUmountSys() {
    return ORBIS_OK;
 }

-int PS4_SYSV_ABI sceSaveDataUmountWithBackup() {
-    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+int PS4_SYSV_ABI sceSaveDataUmountWithBackup(const OrbisSaveDataMountPoint* mountPoint) {
+    LOG_ERROR(Lib_SaveData, "called = {}", std::string(mountPoint->data));
+    auto* mnt = Common::Singleton<Core::FileSys::MntPoints>::Instance();
+    std::string mount_dir = mnt->GetHostFile(mountPoint->data);
+    if (!std::filesystem::exists(mount_dir)) {
+        return ORBIS_SAVE_DATA_ERROR_NOT_FOUND;
+    } else {
+        std::filesystem::path mnt_dir(mount_dir);
+        std::filesystem::create_directories(mnt_dir.parent_path() / "backup");
+
+        for (const auto& entry : std::filesystem::recursive_directory_iterator(mnt_dir)) {
+            const auto& path = entry.path();
+            std::filesystem::path target_path = mnt_dir.parent_path() / "backup";
+
+            if (std::filesystem::is_regular_file(path)) {
+                std::filesystem::copy(path, target_path,
+                                      std::filesystem::copy_options::overwrite_existing);
+            }
+        }
+        mnt->Unmount(mount_dir, mountPoint->data);
+    }
    return ORBIS_OK;
 }

--- a/src/core/libraries/save_data/savedata.h
+++ b/src/core/libraries/save_data/savedata.h
@ -43,19 +43,18 @@ struct OrbisSaveDataMountResult {
 };

 constexpr int ORBIS_SAVE_DATA_TITLE_ID_DATA_SIZE = 10;
-typedef struct OrbisSaveDataTitleId {
+struct OrbisSaveDataTitleId {
    char data[ORBIS_SAVE_DATA_TITLE_ID_DATA_SIZE];
    char padding[6];
-
-} OrbisSaveDataTitleId;
+};

 constexpr int ORBIS_SAVE_DATA_FINGERPRINT_DATA_SIZE = 65;
-typedef struct OrbisSaveDataFingerprint {
+struct OrbisSaveDataFingerprint {
    char data[ORBIS_SAVE_DATA_FINGERPRINT_DATA_SIZE];
    char padding[15];
-} OrbisSaveDataFingerprint;
+};

-typedef struct OrbisSaveDataMount {
+struct OrbisSaveDataMount {
    s32 user_id;
    s32 pad;
    const OrbisSaveDataTitleId* titleId;
@ -64,7 +63,114 @@ typedef struct OrbisSaveDataMount {
    u64 blocks;
    u32 mount_mode;
    u8 reserved[32];
-} OrbisSaveDataMount;
+};
+
+typedef u32 OrbisSaveDataParamType;
+
+constexpr int ORBIS_SAVE_DATA_TITLE_MAXSIZE = 128;
+constexpr int ORBIS_SAVE_DATA_SUBTITLE_MAXSIZE = 128;
+constexpr int ORBIS_SAVE_DATA_DETAIL_MAXSIZE = 1024;
+struct OrbisSaveDataParam {
+    char title[ORBIS_SAVE_DATA_TITLE_MAXSIZE];
+    char subTitle[ORBIS_SAVE_DATA_SUBTITLE_MAXSIZE];
+    char detail[ORBIS_SAVE_DATA_DETAIL_MAXSIZE];
+    u32 userParam;
+    int : 32;
+    time_t mtime;
+    u8 reserved[32];
+};
+
+struct OrbisSaveDataIcon {
+    void* buf;
+    size_t bufSize;
+    size_t dataSize;
+    u8 reserved[32];
+};
+
+typedef u32 OrbisSaveDataSaveDataMemoryOption;
+#define ORBIS_SAVE_DATA_MEMORY_OPTION_NONE (0x00000000)
+#define ORBIS_SAVE_DATA_MEMORY_OPTION_SET_PARAM (0x00000001 << 0)
+#define ORBIS_SAVE_DATA_MEMORY_OPTION_DOUBLE_BUFFER (0x00000001 << 1)
+
+struct OrbisSaveDataMemorySetup2 {
+    OrbisSaveDataSaveDataMemoryOption option;
+    s32 userId;
+    size_t memorySize;
+    size_t iconMemorySize;
+    const OrbisSaveDataParam* initParam;
+    const OrbisSaveDataIcon* initIcon;
+    u32 slotId;
+    u8 reserved[20];
+};
+
+struct OrbisSaveDataMemorySetupResult {
+    size_t existedMemorySize;
+    u8 reserved[16];
+};
+
+typedef u32 OrbisSaveDataEventType;
+#define SCE_SAVE_DATA_EVENT_TYPE_INVALID (0)
+#define SCE_SAVE_DATA_EVENT_TYPE_UMOUNT_BACKUP_END (1)
+#define SCE_SAVE_DATA_EVENT_TYPE_BACKUP_END (2)
+#define SCE_SAVE_DATA_EVENT_TYPE_SAVE_DATA_MEMORY_SYNC_END (3)
+
+struct OrbisSaveDataEvent {
+    OrbisSaveDataEventType type;
+    s32 errorCode;
+    s32 userId;
+    u8 padding[4];
+    OrbisSaveDataTitleId titleId;
+    OrbisSaveDataDirName dirName;
+    u8 reserved[40];
+};
+
+struct OrbisSaveDataMemoryData {
+    void* buf;
+    size_t bufSize;
+    off_t offset;
+    u8 reserved[40];
+};
+
+struct OrbisSaveDataMemoryGet2 {
+    s32 userId;
+    u8 padding[4];
+    OrbisSaveDataMemoryData* data;
+    OrbisSaveDataParam* param;
+    OrbisSaveDataIcon* icon;
+    u32 slotId;
+    u8 reserved[28];
+};
+
+struct OrbisSaveDataMemorySet2 {
+    s32 userId;
+    u8 padding[4];
+    const OrbisSaveDataMemoryData* data;
+    const OrbisSaveDataParam* param;
+    const OrbisSaveDataIcon* icon;
+    u32 dataNum;
+    u8 slotId;
+    u8 reserved[24];
+};
+
+struct OrbisSaveDataCheckBackupData {
+    s32 userId;
+    int : 32;
+    const OrbisSaveDataTitleId* titleId;
+    const OrbisSaveDataDirName* dirName;
+    OrbisSaveDataParam* param;
+    OrbisSaveDataIcon* icon;
+    u8 reserved[32];
+};
+
+struct OrbisSaveDataMountInfo {
+    u64 blocks;
+    u64 freeBlocks;
+    u8 reserved[32];
+};
+
+#define ORBIS_SAVE_DATA_BLOCK_SIZE (32768)
+#define ORBIS_SAVE_DATA_BLOCKS_MIN2 (96)
+#define ORBIS_SAVE_DATA_BLOCKS_MAX (32768)

 // savedataMount2 mountModes (ORed values)
 constexpr int ORBIS_SAVE_DATA_MOUNT_MODE_RDONLY = 1;
@ -73,6 +179,68 @@ constexpr int ORBIS_SAVE_DATA_MOUNT_MODE_CREATE = 4;
 constexpr int ORBIS_SAVE_DATA_MOUNT_MODE_DESTRUCT_OFF = 8;
 constexpr int ORBIS_SAVE_DATA_MOUNT_MODE_COPY_ICON = 16;
 constexpr int ORBIS_SAVE_DATA_MOUNT_MODE_CREATE2 = 32;
+typedef struct _OrbisSaveDataEventParam OrbisSaveDataEventParam;
+
+typedef u32 OrbisSaveDataSortKey;
+#define ORBIS_SAVE_DATA_SORT_KEY_DIRNAME (0)
+#define ORBIS_SAVE_DATA_SORT_KEY_USER_PARAM (1)
+#define ORBIS_SAVE_DATA_SORT_KEY_BLOCKS (2)
+#define ORBIS_SAVE_DATA_SORT_KEY_MTIME (3)
+#define ORBIS_SAVE_DATA_SORT_KEY_FREE_BLOCKS (5)
+
+typedef u32 OrbisSaveDataSortOrder;
+#define ORBIS_SAVE_DATA_SORT_ORDER_ASCENT (0)
+#define ORBIS_SAVE_DATA_SORT_ORDER_DESCENT (1)
+
+struct OrbisSaveDataDirNameSearchCond {
+    s32 userId;
+    int : 32;
+    const OrbisSaveDataTitleId* titleId;
+    const OrbisSaveDataDirName* dirName;
+    OrbisSaveDataSortKey key;
+    OrbisSaveDataSortOrder order;
+    u8 reserved[32];
+};
+
+struct OrbisSaveDataSearchInfo {
+    u64 blocks;
+    u64 freeBlocks;
+    u8 reserved[32];
+};
+
+struct OrbisSaveDataDirNameSearchResult {
+    u32 hitNum;
+    int : 32;
+    OrbisSaveDataDirName* dirNames;
+    u32 dirNamesNum;
+    u32 setNum;
+    OrbisSaveDataParam* params;
+    OrbisSaveDataSearchInfo* infos;
+    u8 reserved[12];
+    int : 32;
+};
+
+struct OrbisSaveDataDelete {
+    s32 userId;
+    int : 32;
+    const OrbisSaveDataTitleId* titleId;
+    const OrbisSaveDataDirName* dirName;
+    u32 unused;
+    u8 reserved[32];
+    int : 32;
+};
+
+typedef u32 OrbisSaveDataMemorySyncOption;
+
+#define SCE_SAVE_DATA_MEMORY_SYNC_OPTION_NONE (0x00000000)
+#define SCE_SAVE_DATA_MEMORY_SYNC_OPTION_BLOCKING (0x00000001 << 0)
+
+struct OrbisSaveDataMemorySync {
+    s32 userId;
+    u32 slotId;
+    OrbisSaveDataMemorySyncOption option;
+    u8 reserved[28];
+};

 int PS4_SYSV_ABI sceSaveDataAbort();
 int PS4_SYSV_ABI sceSaveDataBackup();
@ -80,7 +248,7 @@ int PS4_SYSV_ABI sceSaveDataBindPsnAccount();
 int PS4_SYSV_ABI sceSaveDataBindPsnAccountForSystemBackup();
 int PS4_SYSV_ABI sceSaveDataChangeDatabase();
 int PS4_SYSV_ABI sceSaveDataChangeInternal();
-int PS4_SYSV_ABI sceSaveDataCheckBackupData();
+int PS4_SYSV_ABI sceSaveDataCheckBackupData(const OrbisSaveDataCheckBackupData* check);
 int PS4_SYSV_ABI sceSaveDataCheckBackupDataForCdlg();
 int PS4_SYSV_ABI sceSaveDataCheckBackupDataInternal();
 int PS4_SYSV_ABI sceSaveDataCheckCloudData();
@ -98,12 +266,13 @@ int PS4_SYSV_ABI sceSaveDataDebugCreateSaveDataRoot();
 int PS4_SYSV_ABI sceSaveDataDebugGetThreadId();
 int PS4_SYSV_ABI sceSaveDataDebugRemoveSaveDataRoot();
 int PS4_SYSV_ABI sceSaveDataDebugTarget();
-int PS4_SYSV_ABI sceSaveDataDelete();
+int PS4_SYSV_ABI sceSaveDataDelete(const OrbisSaveDataDelete* del);
 int PS4_SYSV_ABI sceSaveDataDelete5();
 int PS4_SYSV_ABI sceSaveDataDeleteAllUser();
 int PS4_SYSV_ABI sceSaveDataDeleteCloudData();
 int PS4_SYSV_ABI sceSaveDataDeleteUser();
-int PS4_SYSV_ABI sceSaveDataDirNameSearch();
+int PS4_SYSV_ABI sceSaveDataDirNameSearch(const OrbisSaveDataDirNameSearchCond* cond,
+                                          OrbisSaveDataDirNameSearchResult* result);
 int PS4_SYSV_ABI sceSaveDataDirNameSearchInternal();
 int PS4_SYSV_ABI sceSaveDataDownload();
 int PS4_SYSV_ABI sceSaveDataGetAllSize();
@ -116,15 +285,18 @@ int PS4_SYSV_ABI sceSaveDataGetClientThreadPriority();
 int PS4_SYSV_ABI sceSaveDataGetCloudQuotaInfo();
 int PS4_SYSV_ABI sceSaveDataGetDataBaseFilePath();
 int PS4_SYSV_ABI sceSaveDataGetEventInfo();
-int PS4_SYSV_ABI sceSaveDataGetEventResult();
+int PS4_SYSV_ABI sceSaveDataGetEventResult(const OrbisSaveDataEventParam* eventParam,
+                                           OrbisSaveDataEvent* event);
 int PS4_SYSV_ABI sceSaveDataGetFormat();
 int PS4_SYSV_ABI sceSaveDataGetMountedSaveDataCount();
-int PS4_SYSV_ABI sceSaveDataGetMountInfo();
+int PS4_SYSV_ABI sceSaveDataGetMountInfo(const OrbisSaveDataMountPoint* mountPoint,
+                                         OrbisSaveDataMountInfo* info);
 int PS4_SYSV_ABI sceSaveDataGetParam();
 int PS4_SYSV_ABI sceSaveDataGetProgress();
 int PS4_SYSV_ABI sceSaveDataGetSaveDataCount();
-int PS4_SYSV_ABI sceSaveDataGetSaveDataMemory();
-int PS4_SYSV_ABI sceSaveDataGetSaveDataMemory2();
+int PS4_SYSV_ABI sceSaveDataGetSaveDataMemory(const u32 userId, void* buf, const size_t bufSize,
+                                              const int64_t offset);
+int PS4_SYSV_ABI sceSaveDataGetSaveDataMemory2(OrbisSaveDataMemoryGet2* getParam);
 int PS4_SYSV_ABI sceSaveDataGetSaveDataRootDir();
 int PS4_SYSV_ABI sceSaveDataGetSaveDataRootPath();
 int PS4_SYSV_ABI sceSaveDataGetSaveDataRootUsbPath();
@ -136,7 +308,8 @@ int PS4_SYSV_ABI sceSaveDataInitialize3();
 int PS4_SYSV_ABI sceSaveDataInitializeForCdlg();
 int PS4_SYSV_ABI sceSaveDataIsDeletingUsbDb();
 int PS4_SYSV_ABI sceSaveDataIsMounted();
-int PS4_SYSV_ABI sceSaveDataLoadIcon();
+int PS4_SYSV_ABI sceSaveDataLoadIcon(const OrbisSaveDataMountPoint* mountPoint,
+                                     OrbisSaveDataIcon* icon);
 int PS4_SYSV_ABI sceSaveDataMount(const OrbisSaveDataMount* mount,
                                  OrbisSaveDataMountResult* mount_result);
 s32 PS4_SYSV_ABI sceSaveDataMount2(const OrbisSaveDataMount2* mount,
@ -150,24 +323,30 @@ int PS4_SYSV_ABI sceSaveDataRegisterEventCallback();
 int PS4_SYSV_ABI sceSaveDataRestoreBackupData();
 int PS4_SYSV_ABI sceSaveDataRestoreBackupDataForCdlg();
 int PS4_SYSV_ABI sceSaveDataRestoreLoadSaveDataMemory();
-int PS4_SYSV_ABI sceSaveDataSaveIcon();
+int PS4_SYSV_ABI sceSaveDataSaveIcon(const OrbisSaveDataMountPoint* mountPoint,
+                                     const OrbisSaveDataIcon* icon);
 int PS4_SYSV_ABI sceSaveDataSetAutoUploadSetting();
 int PS4_SYSV_ABI sceSaveDataSetEventInfo();
-int PS4_SYSV_ABI sceSaveDataSetParam();
+int PS4_SYSV_ABI sceSaveDataSetParam(const OrbisSaveDataMountPoint* mountPoint,
+                                     OrbisSaveDataParamType paramType, const void* paramBuf,
+                                     size_t paramBufSize);
 int PS4_SYSV_ABI sceSaveDataSetSaveDataLibraryUser();
-int PS4_SYSV_ABI sceSaveDataSetSaveDataMemory();
-int PS4_SYSV_ABI sceSaveDataSetSaveDataMemory2();
-int PS4_SYSV_ABI sceSaveDataSetupSaveDataMemory();
-int PS4_SYSV_ABI sceSaveDataSetupSaveDataMemory2();
+int PS4_SYSV_ABI sceSaveDataSetSaveDataMemory(const u32 userId, const void* buf,
+                                              const size_t bufSize, const int64_t offset);
+int PS4_SYSV_ABI sceSaveDataSetSaveDataMemory2(const OrbisSaveDataMemorySet2* setParam);
+int PS4_SYSV_ABI sceSaveDataSetupSaveDataMemory(u32 userId, size_t memorySize,
+                                                OrbisSaveDataParam* param);
+int PS4_SYSV_ABI sceSaveDataSetupSaveDataMemory2(const OrbisSaveDataMemorySetup2* setupParam,
+                                                 OrbisSaveDataMemorySetupResult* result);
 int PS4_SYSV_ABI sceSaveDataShutdownStart();
 int PS4_SYSV_ABI sceSaveDataSupportedFakeBrokenStatus();
 int PS4_SYSV_ABI sceSaveDataSyncCloudList();
-int PS4_SYSV_ABI sceSaveDataSyncSaveDataMemory();
+int PS4_SYSV_ABI sceSaveDataSyncSaveDataMemory(OrbisSaveDataMemorySync* syncParam);
 int PS4_SYSV_ABI sceSaveDataTerminate();
 int PS4_SYSV_ABI sceSaveDataTransferringMount();
 int PS4_SYSV_ABI sceSaveDataUmount(const OrbisSaveDataMountPoint* mountPoint);
 int PS4_SYSV_ABI sceSaveDataUmountSys();
-int PS4_SYSV_ABI sceSaveDataUmountWithBackup();
+int PS4_SYSV_ABI sceSaveDataUmountWithBackup(const OrbisSaveDataMountPoint* mountPoint);
 int PS4_SYSV_ABI sceSaveDataUnregisterEventCallback();
 int PS4_SYSV_ABI sceSaveDataUpload();
 int PS4_SYSV_ABI Func_02E4C4D201716422();
--- a/src/emulator.cpp
+++ b/src/emulator.cpp
@ -15,12 +15,14 @@
 #include "common/logging/backend.h"
 #include "common/path_util.h"
 #include "common/singleton.h"
+#include "common/version.h"
 #include "core/file_sys/fs.h"
 #include "core/libraries/kernel/thread_management.h"
 #include "core/libraries/libs.h"
 #include "core/linker.h"
 #include "core/memory.h"
 #include "emulator.h"
+#include "hwinfo/hwinfo.h"

 Frontend::WindowSDL* g_window = nullptr;

@ -40,6 +42,8 @@ Emulator::Emulator()
    // Start logger.
    Common::Log::Initialize();
    Common::Log::Start();
+    LOG_INFO(Loader, "Starting shadps4 emulator v{} ", Common::VERSION);
+    PrintSystemInfo();
 }

 Emulator::~Emulator() {
@ -85,6 +89,9 @@ void Emulator::Run(const std::filesystem::path& file) {
    }
    mnt->Mount(mount_data_dir, "/data"); // should just exist, manually create with game serial
    const auto& mount_temp_dir = Common::FS::GetUserPath(Common::FS::PathType::TempDataDir) / id;
+    if (!std::filesystem::exists(mount_temp_dir)) {
+        std::filesystem::create_directory(mount_temp_dir);
+    }
    mnt->Mount(mount_temp_dir, "/temp0"); // called in app_content ==> stat/mkdir

    // Initialize kernel and library facilities.
@ -174,4 +181,17 @@ void Emulator::LoadSystemModules(const std::filesystem::path& file) {
    }
 }

+void Emulator::PrintSystemInfo() {
+    auto cpus = hwinfo::getAllCPUs();
+    for (const auto& cpu : cpus) {
+        LOG_INFO(Loader, "CPU #{} {}", cpu.id(), cpu.modelName());
+    }
+    hwinfo::OS os;
+    LOG_INFO(Loader, "{}", os.name());
+    auto gpus = hwinfo::getAllGPUs();
+    for (auto& gpu : gpus) {
+        LOG_INFO(Loader, "GPU #{} {}", gpu.id(), gpu.name());
+    }
+}
+
 } // namespace Core
--- a/src/emulator.h
+++ b/src/emulator.h
@ -29,6 +29,7 @@ public:

 private:
    void LoadSystemModules(const std::filesystem::path& file);
+    void PrintSystemInfo();

    Core::MemoryManager* memory;
    Input::GameController* controller = Common::Singleton<Input::GameController>::Instance();
				`@ -0,0 +1 @@`
				`Subproject commit 81ea6332fd4839890b1904f9668865145450f8da`