Merge branch 'shadps4-emu:main' into main

CMakeLists.txt

@@ -105,6 +105,8 @@ set(KERNEL_LIB
                src/core/libraries/kernel/event_flag/event_flag.h
                src/core/libraries/kernel/event_flag/event_flag_obj.cpp
                src/core/libraries/kernel/event_flag/event_flag_obj.h
+               src/core/libraries/kernel/threads/kernel_threads.h
+               src/core/libraries/kernel/threads/kernel_threads_rwlock.cpp
                src/core/libraries/kernel/cpu_management.cpp
                src/core/libraries/kernel/cpu_management.h
                src/core/libraries/kernel/event_queue.cpp
@@ -152,6 +154,11 @@ set(SYSTEM_LIBS src/core/libraries/system/commondialog.cpp
                 src/core/libraries/system/userservice.h
                 src/core/libraries/app_content/app_content.cpp
                 src/core/libraries/app_content/app_content.h
+                src/core/libraries/rtc/rtc.cpp
+                src/core/libraries/rtc/rtc.h
+                src/core/libraries/disc_map/disc_map.cpp
+                src/core/libraries/disc_map/disc_map.h
+                src/core/libraries/disc_map/disc_map_codes.h
 )
 
 set(VIDEOOUT_LIB src/core/libraries/videoout/buffer.h
@@ -233,6 +240,7 @@ set(COMMON src/common/logging/backend.cpp
            src/common/rdtsc.cpp
            src/common/rdtsc.h
            src/common/singleton.h
+           src/common/slot_vector.h
            src/common/string_util.cpp
            src/common/string_util.h
            src/common/thread.cpp
@@ -413,7 +421,6 @@ set(VIDEO_CORE src/video_core/amdgpu/liverpool.cpp
                src/video_core/texture_cache/image_view.h
                src/video_core/texture_cache/sampler.cpp
                src/video_core/texture_cache/sampler.h
-               src/video_core/texture_cache/slot_vector.h
                src/video_core/texture_cache/texture_cache.cpp
                src/video_core/texture_cache/texture_cache.h
                src/video_core/texture_cache/tile_manager.cpp

src/common/logging/filter.cpp

@@ -102,6 +102,8 @@ bool ParseFilterRule(Filter& instance, Iterator begin, Iterator end) {
     SUB(Lib, Screenshot)                                                                           \
     SUB(Lib, LibCInternal)                                                                         \
     SUB(Lib, AppContent)                                                                           \
+    SUB(Lib, Rtc)                                                                                  \
+    SUB(Lib, DiscMap)                                                                              \
     CLS(Frontend)                                                                                  \
     CLS(Render)                                                                                    \
     SUB(Render, Vulkan)                                                                            \

src/common/logging/types.h

@@ -69,6 +69,8 @@ enum class Class : u8 {
     Lib_Screenshot,     ///< The LibSceScreenshot implementation
     Lib_LibCInternal,   ///< The LibCInternal implementation.
     Lib_AppContent,     ///< The LibSceAppContent implementation.
+    Lib_Rtc,            ///< The LibSceRtc implementation.
+    Lib_DiscMap,        ///< The LibSceDiscMap implementation.
     Frontend,           ///< Emulator UI
     Render,             ///< Video Core
     Render_Vulkan,      ///< Vulkan backend

src/core/address_space.cpp

@@ -113,8 +113,10 @@ struct AddressSpace::Impl {
         return ptr;
     }
 
-    void* MapPrivate(VAddr virtual_addr, size_t size, u64 alignment, ULONG prot) {
+    void* MapPrivate(VAddr virtual_addr, size_t size, u64 alignment, ULONG prot,
+                     bool no_commit = false) {
         // Map a private allocation
+        PVOID addr = reinterpret_cast<PVOID>(virtual_addr);
         MEM_ADDRESS_REQUIREMENTS req{};
         MEM_EXTENDED_PARAMETER param{};
         // req.LowestStartingAddress =
@@ -124,9 +126,27 @@ struct AddressSpace::Impl {
         req.Alignment = alignment < 64_KB ? 0 : alignment;
         param.Type = MemExtendedParameterAddressRequirements;
         param.Pointer = &req;
-        ULONG alloc_type = MEM_COMMIT | MEM_RESERVE | (alignment > 2_MB ? MEM_LARGE_PAGES : 0);
-        void* const ptr = VirtualAlloc2(process, nullptr, size, alloc_type, prot, &param, 1);
-        ASSERT_MSG(ptr, "{}", Common::GetLastErrorMsg());
+        ULONG alloc_type = MEM_RESERVE | (alignment > 2_MB ? MEM_LARGE_PAGES : 0);
+        if (!no_commit) {
+            alloc_type |= MEM_COMMIT;
+        }
+        // Check if the area has been reserved beforehand (typically for tesselation buffer)
+        // and in that case don't reserve it again as Windows complains.
+        if (virtual_addr) {
+            MEMORY_BASIC_INFORMATION info;
+            VirtualQuery(addr, &info, sizeof(info));
+            if (info.State == MEM_RESERVE) {
+                alloc_type &= ~MEM_RESERVE;
+            }
+        }
+        void* ptr{};
+        if (virtual_addr) {
+            ptr = VirtualAlloc2(process, addr, size, alloc_type, prot, NULL, 0);
+            ASSERT_MSG(ptr && VAddr(ptr) == virtual_addr, "{}", Common::GetLastErrorMsg());
+        } else {
+            ptr = VirtualAlloc2(process, nullptr, size, alloc_type, prot, &param, 1);
+            ASSERT_MSG(ptr, "{}", Common::GetLastErrorMsg());
+        }
         return ptr;
     }
 
@@ -224,7 +244,8 @@ struct AddressSpace::Impl {
         return nullptr;
     }
 
-    void* MapPrivate(VAddr virtual_addr, size_t size, u64 alignment, PosixPageProtection prot) {
+    void* MapPrivate(VAddr virtual_addr, size_t size, u64 alignment, PosixPageProtection prot,
+                     bool no_commit = false) {
         UNREACHABLE();
         return nullptr;
     }
@@ -271,4 +292,8 @@ void AddressSpace::Protect(VAddr virtual_addr, size_t size, MemoryPermission per
     return impl->Protect(virtual_addr, size, true, true, true);
 }
 
+void* AddressSpace::Reserve(size_t size, u64 alignment) {
+    return impl->MapPrivate(0, size, alignment, PAGE_READWRITE, true);
+}
+
 } // namespace Core

src/core/address_space.h

@@ -49,6 +49,8 @@ public:
 
     void Protect(VAddr virtual_addr, size_t size, MemoryPermission perms);
 
+    void* Reserve(size_t size, u64 alignment);
+
 private:
     struct Impl;
     std::unique_ptr<Impl> impl;

src/core/libraries/disc_map/disc_map.cpp

@@ -0,0 +1,48 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+// Generated By moduleGenerator
+#include "common/logging/log.h"
+#include "core/libraries/error_codes.h"
+#include "core/libraries/libs.h"
+#include "disc_map.h"
+#include "disc_map_codes.h"
+
+namespace Libraries::DiscMap {
+
+int PS4_SYSV_ABI sceDiscMapGetPackageSize() {
+    LOG_WARNING(Lib_DiscMap, "(DUMMY) called");
+    return ORBIS_DISC_MAP_ERROR_NO_BITMAP_INFO;
+}
+
+int PS4_SYSV_ABI sceDiscMapIsRequestOnHDD() {
+    LOG_WARNING(Lib_DiscMap, "(DUMMY) called");
+    return ORBIS_DISC_MAP_ERROR_NO_BITMAP_INFO;
+}
+
+int PS4_SYSV_ABI Func_7C980FFB0AA27E7A() {
+    LOG_ERROR(Lib_DiscMap, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI Func_8A828CAEE7EDD5E9() {
+    LOG_ERROR(Lib_DiscMap, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI Func_E7EBCE96E92F91F8() {
+    LOG_ERROR(Lib_DiscMap, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+void RegisterlibSceDiscMap(Core::Loader::SymbolsResolver* sym) {
+    LIB_FUNCTION("fl1eoDnwQ4s", "libSceDiscMap", 1, "libSceDiscMap", 1, 1,
+                 sceDiscMapGetPackageSize);
+    LIB_FUNCTION("lbQKqsERhtE", "libSceDiscMap", 1, "libSceDiscMap", 1, 1,
+                 sceDiscMapIsRequestOnHDD);
+    LIB_FUNCTION("fJgP+wqifno", "libSceDiscMap", 1, "libSceDiscMap", 1, 1, Func_7C980FFB0AA27E7A);
+    LIB_FUNCTION("ioKMruft1ek", "libSceDiscMap", 1, "libSceDiscMap", 1, 1, Func_8A828CAEE7EDD5E9);
+    LIB_FUNCTION("5+vOlukvkfg", "libSceDiscMap", 1, "libSceDiscMap", 1, 1, Func_E7EBCE96E92F91F8);
+};
+
+} // namespace Libraries::DiscMap

src/core/libraries/disc_map/disc_map.h

@@ -0,0 +1,20 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "common/types.h"
+
+namespace Core::Loader {
+class SymbolsResolver;
+}
+namespace Libraries::DiscMap {
+
+int PS4_SYSV_ABI sceDiscMapGetPackageSize();
+int PS4_SYSV_ABI sceDiscMapIsRequestOnHDD();
+int PS4_SYSV_ABI Func_7C980FFB0AA27E7A();
+int PS4_SYSV_ABI Func_8A828CAEE7EDD5E9();
+int PS4_SYSV_ABI Func_E7EBCE96E92F91F8();
+
+void RegisterlibSceDiscMap(Core::Loader::SymbolsResolver* sym);
+} // namespace Libraries::DiscMap

src/core/libraries/disc_map/disc_map_codes.h

@@ -0,0 +1,10 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+constexpr int ORBIS_DISC_MAP_ERROR_INVALID_ARGUMENT = 0x81100001;
+constexpr int ORBIS_DISC_MAP_ERROR_LOCATION_NOT_MAPPED = 0x81100002;
+constexpr int ORBIS_DISC_MAP_ERROR_FILE_NOT_FOUND = 0x81100003;
+constexpr int ORBIS_DISC_MAP_ERROR_NO_BITMAP_INFO = 0x81100004;
+constexpr int ORBIS_DISC_MAP_ERROR_FATAL = 0x811000FF;

src/core/libraries/error_codes.h

@@ -246,11 +246,19 @@ constexpr int SCE_VIDEO_OUT_ERROR_SLOT_OCCUPIED = 0x80290010;        // slot alr
 constexpr int SCE_VIDEO_OUT_ERROR_FLIP_QUEUE_FULL = 0x80290012;      // flip queue is full
 constexpr int SCE_VIDEO_OUT_ERROR_INVALID_OPTION = 0x8029001A; // Invalid buffer attribute option
 
+// GnmDriver
+constexpr int ORBIS_GNM_ERROR_COMPUTEQUEUE_INVALID_PIPE_ID = 0x80D17000;
+constexpr int ORBIS_GNM_ERROR_COMPUTEQUEUE_INVALID_QUEUE_ID = 0x80D17001;
+constexpr int ORBIS_GNM_ERROR_COMPUTEQUEUE_INVALID_RING_BASE_ADDR = 0x80D17003;
+constexpr int ORBIS_GNM_ERROR_COMPUTEQUEUE_INVALID_RING_SIZE = 0x80D17002;
+constexpr int ORBIS_GNM_ERROR_COMPUTEQUEUE_INVALID_READ_PTR_ADDR = 0x80D17004;
+
 // Generic
 constexpr int ORBIS_OK = 0x00000000;
 constexpr int ORBIS_FAIL = 0xFFFFFFFF;
 
 // Libkernel library
+constexpr int ORBIS_KERNEL_ERROR_UNKNOWN = 0x80020000;
 constexpr int ORBIS_KERNEL_ERROR_EPERM = 0x80020001;
 constexpr int ORBIS_KERNEL_ERROR_ENOENT = 0x80020002;
 constexpr int ORBIS_KERNEL_ERROR_ESRCH = 0x80020003;

src/core/libraries/gnmdriver/gnmdriver.cpp

@@ -5,10 +5,12 @@
 #include "common/config.h"
 #include "common/logging/log.h"
 #include "common/path_util.h"
+#include "common/slot_vector.h"
 #include "core/libraries/error_codes.h"
 #include "core/libraries/gnmdriver/gnmdriver.h"
 #include "core/libraries/libs.h"
 #include "core/libraries/videoout/video_out.h"
+#include "core/memory.h"
 #include "core/platform.h"
 #include "video_core/amdgpu/liverpool.h"
 #include "video_core/amdgpu/pm4_cmds.h"
@@ -32,6 +34,17 @@ static constexpr bool g_fair_hw_init = false;
 static u32 submission_lock{};
 static u64 frames_submitted{}; // frame counter
 
+struct AscQueueInfo {
+    VAddr map_addr;
+    u32* read_addr;
+    u32 ring_size_dw;
+};
+static VideoCore::SlotVector<AscQueueInfo> asc_queues{};
+
+static constexpr u32 TessellationFactorRingSize = 128_KB;
+static constexpr u32 TessellationFactorRingAlignment = 64_KB; // toolkit is using this alignment
+VAddr tessellation_factors_ring_addr{0};
+
 static void DumpCommandList(std::span<const u32> cmd_list, const std::string& postfix) {
     using namespace Common::FS;
     const auto dump_dir = GetUserPath(PathType::PM4Dir);
@@ -367,9 +380,18 @@ int PS4_SYSV_ABI sceGnmDrawInitDefaultHardwareState() {
     return ORBIS_OK;
 }
 
-int PS4_SYSV_ABI sceGnmDrawInitDefaultHardwareState175() {
-    LOG_ERROR(Lib_GnmDriver, "(STUBBED) called");
-    return ORBIS_OK;
+u32 PS4_SYSV_ABI sceGnmDrawInitDefaultHardwareState175(u32* cmdbuf, u32 size) {
+    LOG_TRACE(Lib_GnmDriver, "called");
+
+    if (size > 0xff) {
+        if constexpr (g_fair_hw_init) {
+            ASSERT_MSG(0, "Not implemented");
+        } else {
+            cmdbuf = WriteHeader<PM4ItOpcode::Nop>(cmdbuf, 0xff);
+        }
+        return 0x100; // it is a size, not a retcode
+    }
+    return 0;
 }
 
 u32 PS4_SYSV_ABI sceGnmDrawInitDefaultHardwareState200(u32* cmdbuf, u32 size) {
@@ -379,7 +401,7 @@ u32 PS4_SYSV_ABI sceGnmDrawInitDefaultHardwareState200(u32* cmdbuf, u32 size) {
         if constexpr (g_fair_hw_init) {
             ASSERT_MSG(0, "Not implemented");
         } else {
-            cmdbuf = cmdbuf = WriteHeader<PM4ItOpcode::Nop>(cmdbuf, 0xff);
+            cmdbuf = WriteHeader<PM4ItOpcode::Nop>(cmdbuf, 0xff);
         }
         return 0x100; // it is a size, not a retcode
     }
@@ -393,7 +415,7 @@ u32 PS4_SYSV_ABI sceGnmDrawInitDefaultHardwareState350(u32* cmdbuf, u32 size) {
         if constexpr (g_fair_hw_init) {
             ASSERT_MSG(0, "Not implemented");
         } else {
-            cmdbuf = cmdbuf = WriteHeader<PM4ItOpcode::Nop>(cmdbuf, 0xff);
+            cmdbuf = WriteHeader<PM4ItOpcode::Nop>(cmdbuf, 0xff);
         }
         return 0x100; // it is a size, not a retcode
     }
@@ -599,9 +621,15 @@ int PS4_SYSV_ABI sceGnmGetShaderStatus() {
     return ORBIS_OK;
 }
 
-int PS4_SYSV_ABI sceGnmGetTheTessellationFactorRingBufferBaseAddress() {
-    LOG_ERROR(Lib_GnmDriver, "(STUBBED) called");
-    return ORBIS_OK;
+VAddr PS4_SYSV_ABI sceGnmGetTheTessellationFactorRingBufferBaseAddress() {
+    LOG_TRACE(Lib_GnmDriver, "called");
+    // Actual virtual buffer address is hardcoded in the driver to 0xff00'000
+    if (tessellation_factors_ring_addr == 0) {
+        auto* memory = Core::Memory::Instance();
+        tessellation_factors_ring_addr =
+            memory->Reserve(TessellationFactorRingSize, TessellationFactorRingAlignment);
+    }
+    return tessellation_factors_ring_addr;
 }
 
 int PS4_SYSV_ABI sceGnmGpuPaDebugEnter() {
@@ -718,14 +746,44 @@ int PS4_SYSV_ABI sceGnmLogicalTcaUnitToPhysical() {
     return ORBIS_OK;
 }
 
-int PS4_SYSV_ABI sceGnmMapComputeQueue() {
-    LOG_ERROR(Lib_GnmDriver, "(STUBBED) called");
-    return ORBIS_OK;
+int PS4_SYSV_ABI sceGnmMapComputeQueue(u32 pipe_id, u32 queue_id, VAddr ring_base_addr,
+                                       u32 ring_size_dw, u32* read_ptr_addr) {
+    LOG_TRACE(Lib_GnmDriver, "called");
+
+    if (pipe_id >= Liverpool::NumComputePipes) {
+        return ORBIS_GNM_ERROR_COMPUTEQUEUE_INVALID_PIPE_ID;
+    }
+
+    if (queue_id >= Liverpool::NumQueuesPerPipe) {
+        return ORBIS_GNM_ERROR_COMPUTEQUEUE_INVALID_QUEUE_ID;
+    }
+
+    if (VAddr(ring_base_addr) % 256 != 0) { // alignment check
+        return ORBIS_GNM_ERROR_COMPUTEQUEUE_INVALID_RING_BASE_ADDR;
+    }
+
+    if (!std::has_single_bit(ring_size_dw)) {
+        return ORBIS_GNM_ERROR_COMPUTEQUEUE_INVALID_RING_SIZE;
+    }
+
+    if (VAddr(read_ptr_addr) % 4 != 0) { // alignment check
+        return ORBIS_GNM_ERROR_COMPUTEQUEUE_INVALID_READ_PTR_ADDR;
+    }
+
+    auto vqid = asc_queues.insert(VAddr(ring_base_addr), read_ptr_addr, ring_size_dw);
+    LOG_INFO(Lib_GnmDriver, "ASC pipe {} queue {} mapped to vqueue {}", pipe_id, queue_id,
+             vqid.index);
+
+    return vqid.index;
 }
 
-int PS4_SYSV_ABI sceGnmMapComputeQueueWithPriority() {
-    LOG_ERROR(Lib_GnmDriver, "(STUBBED) called");
-    return ORBIS_OK;
+int PS4_SYSV_ABI sceGnmMapComputeQueueWithPriority(u32 pipe_id, u32 queue_id, VAddr ring_base_addr,
+                                                   u32 ring_size_dw, u32* read_ptr_addr,
+                                                   u32 pipePriority) {
+    LOG_TRACE(Lib_GnmDriver, "called");
+
+    (void)pipePriority;
+    return sceGnmMapComputeQueue(pipe_id, queue_id, ring_base_addr, ring_size_dw, read_ptr_addr);
 }
 
 int PS4_SYSV_ABI sceGnmPaDisableFlipCallbacks() {

src/core/libraries/gnmdriver/gnmdriver.h

@@ -54,7 +54,7 @@ int PS4_SYSV_ABI sceGnmDrawIndirect();
 int PS4_SYSV_ABI sceGnmDrawIndirectCountMulti();
 int PS4_SYSV_ABI sceGnmDrawIndirectMulti();
 int PS4_SYSV_ABI sceGnmDrawInitDefaultHardwareState();
-int PS4_SYSV_ABI sceGnmDrawInitDefaultHardwareState175();
+u32 PS4_SYSV_ABI sceGnmDrawInitDefaultHardwareState175(u32* cmdbuf, u32 size);
 u32 PS4_SYSV_ABI sceGnmDrawInitDefaultHardwareState200(u32* cmdbuf, u32 size);
 u32 PS4_SYSV_ABI sceGnmDrawInitDefaultHardwareState350(u32* cmdbuf, u32 size);
 int PS4_SYSV_ABI sceGnmDrawInitToDefaultContextState();
@@ -97,7 +97,7 @@ int PS4_SYSV_ABI sceGnmGetResourceType();
 int PS4_SYSV_ABI sceGnmGetResourceUserData();
 int PS4_SYSV_ABI sceGnmGetShaderProgramBaseAddress();
 int PS4_SYSV_ABI sceGnmGetShaderStatus();
-int PS4_SYSV_ABI sceGnmGetTheTessellationFactorRingBufferBaseAddress();
+VAddr PS4_SYSV_ABI sceGnmGetTheTessellationFactorRingBufferBaseAddress();
 int PS4_SYSV_ABI sceGnmGpuPaDebugEnter();
 int PS4_SYSV_ABI sceGnmGpuPaDebugLeave();
 int PS4_SYSV_ABI sceGnmInsertDingDongMarker();
@@ -113,8 +113,11 @@ int PS4_SYSV_ABI sceGnmIsUserPaEnabled();
 int PS4_SYSV_ABI sceGnmLogicalCuIndexToPhysicalCuIndex();
 int PS4_SYSV_ABI sceGnmLogicalCuMaskToPhysicalCuMask();
 int PS4_SYSV_ABI sceGnmLogicalTcaUnitToPhysical();
-int PS4_SYSV_ABI sceGnmMapComputeQueue();
-int PS4_SYSV_ABI sceGnmMapComputeQueueWithPriority();
+int PS4_SYSV_ABI sceGnmMapComputeQueue(u32 pipe_id, u32 queue_id, VAddr ring_base_addr,
+                                       u32 ring_size_dw, u32* read_ptr_addr);
+int PS4_SYSV_ABI sceGnmMapComputeQueueWithPriority(u32 pipe_id, u32 queue_id, VAddr ring_base_addr,
+                                                   u32 ring_size_dw, u32* read_ptr_addr,
+                                                   u32 pipePriority);
 int PS4_SYSV_ABI sceGnmPaDisableFlipCallbacks();
 int PS4_SYSV_ABI sceGnmPaEnableFlipCallbacks();
 int PS4_SYSV_ABI sceGnmPaHeartbeat();

src/core/libraries/kernel/event_queues.cpp

@@ -102,4 +102,13 @@ void* PS4_SYSV_ABI sceKernelGetEventUserData(const SceKernelEvent* ev) {
     return ev->udata;
 }
 
+int PS4_SYSV_ABI sceKernelTriggerUserEvent(SceKernelEqueue eq, int id, void* udata) {
+    eq->triggerEvent(id, Kernel::EVFILT_USER, udata);
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceKernelDeleteUserEvent(SceKernelEqueue eq, int id) {
+    eq->removeEvent(id);
+    return ORBIS_OK;
+}
 } // namespace Libraries::Kernel

src/core/libraries/kernel/event_queues.h

@@ -15,6 +15,8 @@ int PS4_SYSV_ABI sceKernelDeleteEqueue(SceKernelEqueue eq);
 int PS4_SYSV_ABI sceKernelWaitEqueue(SceKernelEqueue eq, SceKernelEvent* ev, int num, int* out,
                                      SceKernelUseconds* timo);
 void* PS4_SYSV_ABI sceKernelGetEventUserData(const SceKernelEvent* ev);
+int PS4_SYSV_ABI sceKernelTriggerUserEvent(SceKernelEqueue eq, int id, void* udata);
+int PS4_SYSV_ABI sceKernelDeleteUserEvent(SceKernelEqueue eq, int id);
 int PS4_SYSV_ABI sceKernelAddUserEvent(SceKernelEqueue eq, int id);
 
 } // namespace Libraries::Kernel

src/core/libraries/kernel/file_system.cpp

@@ -42,6 +42,14 @@ int PS4_SYSV_ABI sceKernelOpen(const char* path, int flags, u16 mode) {
             file->f.Open(file->m_host_name, Common::FS::FileAccessMode::Read);
         } else if (write && create && truncate) {
             file->f.Open(file->m_host_name, Common::FS::FileAccessMode::Write);
+        } else if (write && create && append) { // CUSA04729 (appends app0/shaderlist.txt)
+            file->f.Open(file->m_host_name, Common::FS::FileAccessMode::Append);
+        } else if (rdwr) {
+            if (create) { // Create an empty file first.
+                Common::FS::IOFile out(file->m_host_name, Common::FS::FileAccessMode::Write);
+            }
+            // RW, then scekernelWrite is called and savedata is written just fine now.
+            file->f.Open(file->m_host_name, Common::FS::FileAccessMode::ReadWrite);
         } else {
             UNREACHABLE();
         }
@@ -64,6 +72,9 @@ int PS4_SYSV_ABI posix_open(const char* path, int flags, /* SceKernelMode*/ u16
 }
 
 int PS4_SYSV_ABI sceKernelClose(int d) {
+    if (d < 3) { // d probably hold an error code
+        return ORBIS_KERNEL_ERROR_EPERM;
+    }
     auto* h = Common::Singleton<Core::FileSys::HandleTable>::Instance();
     auto* file = h->GetFile(d);
     if (file == nullptr) {
@@ -203,6 +214,56 @@ int PS4_SYSV_ABI posix_stat(const char* path, OrbisKernelStat* sb) {
     return ORBIS_OK;
 }
 
+s64 PS4_SYSV_ABI sceKernelPread(int d, void* buf, size_t nbytes, s64 offset) {
+    if (d < 3) {
+        return ORBIS_KERNEL_ERROR_EPERM;
+    }
+
+    if (buf == nullptr) {
+        return ORBIS_KERNEL_ERROR_EFAULT;
+    }
+
+    if (offset < 0) {
+        return ORBIS_KERNEL_ERROR_EINVAL;
+    }
+
+    auto* h = Common::Singleton<Core::FileSys::HandleTable>::Instance();
+    auto* file = h->GetFile(d);
+
+    if (file == nullptr) {
+        return ORBIS_KERNEL_ERROR_EBADF;
+    }
+    file->m_mutex.lock();
+    if (file->f.Tell() != offset) {
+        file->f.Seek(offset);
+    }
+    u32 bytes_read = file->f.ReadRaw<u8>(buf, static_cast<u32>(nbytes));
+    file->m_mutex.unlock();
+    return bytes_read;
+}
+
+int PS4_SYSV_ABI sceKernelFStat(int fd, OrbisKernelStat* sb) {
+    LOG_INFO(Kernel_Fs, "(PARTIAL) fd = {}", fd);
+    auto* h = Common::Singleton<Core::FileSys::HandleTable>::Instance();
+    auto* file = h->GetFile(fd);
+    memset(sb, 0, sizeof(OrbisKernelStat));
+
+    if (file->is_directory) {
+        sb->st_mode = 0000777u | 0040000u;
+        sb->st_size = 0;
+        sb->st_blksize = 512;
+        sb->st_blocks = 0;
+        // TODO incomplete
+    } else {
+        sb->st_mode = 0000777u | 0100000u;
+        sb->st_size = file->f.GetSize();
+        sb->st_blksize = 512;
+        sb->st_blocks = (sb->st_size + 511) / 512;
+        // TODO incomplete
+    }
+    return ORBIS_OK;
+}
+
 void fileSystemSymbolsRegister(Core::Loader::SymbolsResolver* sym) {
     LIB_FUNCTION("1G3lF1Gg1k8", "libkernel", 1, "libkernel", 1, 1, sceKernelOpen);
     LIB_FUNCTION("wuCroIGjt2g", "libScePosix", 1, "libkernel", 1, 1, posix_open);
@@ -215,7 +276,10 @@ void fileSystemSymbolsRegister(Core::Loader::SymbolsResolver* sym) {
     LIB_FUNCTION("Cg4srZ6TKbU", "libkernel", 1, "libkernel", 1, 1, sceKernelRead);
     LIB_FUNCTION("1-LFLmRFxxM", "libkernel", 1, "libkernel", 1, 1, sceKernelMkdir);
     LIB_FUNCTION("eV9wAD2riIA", "libkernel", 1, "libkernel", 1, 1, sceKernelStat);
+    LIB_FUNCTION("kBwCPsYX-m4", "libkernel", 1, "libkernel", 1, 1, sceKernelFStat);
+
     LIB_FUNCTION("E6ao34wPw+U", "libScePosix", 1, "libkernel", 1, 1, posix_stat);
+    LIB_FUNCTION("+r3rMFwItV4", "libkernel", 1, "libkernel", 1, 1, sceKernelPread);
 
     // openOrbis (to check if it is valid out of OpenOrbis
     LIB_FUNCTION("6c3rCVE-fTU", "libkernel", 1, "libkernel", 1, 1,

src/core/libraries/kernel/libkernel.cpp

@@ -53,8 +53,19 @@ int PS4_SYSV_ABI sceKernelMunmap(void* addr, size_t len) {
     return SCE_OK;
 }
 
-void PS4_SYSV_ABI sceKernelUsleep(u32 microseconds) {
+int PS4_SYSV_ABI sceKernelUsleep(u32 microseconds) {
     std::this_thread::sleep_for(std::chrono::microseconds(microseconds));
+    return SCE_OK;
+}
+
+int PS4_SYSV_ABI posix_usleep(u32 microseconds) {
+    std::this_thread::sleep_for(std::chrono::microseconds(microseconds));
+    return SCE_OK;
+}
+
+int PS4_SYSV_ABI sceKernelSleep(u32 seconds) {
+    std::this_thread::sleep_for(std::chrono::seconds(seconds));
+    return SCE_OK;
 }
 
 struct iovec {
@@ -243,6 +254,7 @@ void LibKernel_Register(Core::Loader::SymbolsResolver* sym) {
     LIB_FUNCTION("B+vc2AO2Zrc", "libkernel", 1, "libkernel", 1, 1,
                  sceKernelAllocateMainDirectMemory);
     LIB_FUNCTION("pO96TwzOm5E", "libkernel", 1, "libkernel", 1, 1, sceKernelGetDirectMemorySize);
+    LIB_FUNCTION("NcaWUxfMNIQ", "libkernel", 1, "libkernel", 1, 1, sceKernelMapNamedDirectMemory);
     LIB_FUNCTION("L-Q3LEjIbgA", "libkernel", 1, "libkernel", 1, 1, sceKernelMapDirectMemory);
     LIB_FUNCTION("WFcfL2lzido", "libkernel", 1, "libkernel", 1, 1, sceKernelQueryMemoryProtection);
     LIB_FUNCTION("BHouLQzh0X0", "libkernel", 1, "libkernel", 1, 1, sceKernelDirectMemoryQuery);
@@ -261,12 +273,17 @@ void LibKernel_Register(Core::Loader::SymbolsResolver* sym) {
     LIB_FUNCTION("fzyMKs9kim0", "libkernel", 1, "libkernel", 1, 1, sceKernelWaitEqueue);
     LIB_FUNCTION("vz+pg2zdopI", "libkernel", 1, "libkernel", 1, 1, sceKernelGetEventUserData);
     LIB_FUNCTION("4R6-OvI2cEA", "libkernel", 1, "libkernel", 1, 1, sceKernelAddUserEvent);
+    LIB_FUNCTION("F6e0kwo4cnk", "libkernel", 1, "libkernel", 1, 1, sceKernelTriggerUserEvent);
+    LIB_FUNCTION("LJDwdSNTnDg", "libkernel", 1, "libkernel", 1, 1, sceKernelDeleteUserEvent);
+
     // misc
     LIB_FUNCTION("WslcK1FQcGI", "libkernel", 1, "libkernel", 1, 1, sceKernelIsNeoMode);
     LIB_FUNCTION("Ou3iL1abvng", "libkernel", 1, "libkernel", 1, 1, stack_chk_fail);
     LIB_FUNCTION("9BcDykPmo1I", "libkernel", 1, "libkernel", 1, 1, __Error);
     LIB_FUNCTION("BPE9s9vQQXo", "libkernel", 1, "libkernel", 1, 1, posix_mmap);
     LIB_FUNCTION("1jfXLRVzisc", "libkernel", 1, "libkernel", 1, 1, sceKernelUsleep);
+    LIB_FUNCTION("QcteRwbsnV0", "libScePosix", 1, "libkernel", 1, 1, posix_usleep);
+    LIB_FUNCTION("-ZR+hG7aDHw", "libkernel", 1, "libkernel", 1, 1, sceKernelSleep);
     LIB_FUNCTION("YSHRBRLn2pI", "libkernel", 1, "libkernel", 1, 1, _writev);
     LIB_FUNCTION("959qrazPIrg", "libkernel", 1, "libkernel", 1, 1, sceKernelGetProcParam);
     LIB_FUNCTION("-o5uEDpN+oY", "libkernel", 1, "libkernel", 1, 1, sceKernelConvertUtcToLocaltime);

src/core/libraries/kernel/memory_management.cpp

@@ -55,8 +55,9 @@ s32 PS4_SYSV_ABI sceKernelAllocateMainDirectMemory(size_t len, size_t alignment,
                                          physAddrOut);
 }
 
-int PS4_SYSV_ABI sceKernelMapDirectMemory(void** addr, u64 len, int prot, int flags,
-                                          s64 directMemoryStart, u64 alignment) {
+int PS4_SYSV_ABI sceKernelMapNamedDirectMemory(void** addr, u64 len, int prot, int flags,
+                                               s64 directMemoryStart, u64 alignment,
+                                               const char* name) {
     LOG_INFO(
         Kernel_Vmm,
         "len = {:#x}, prot = {:#x}, flags = {:#x}, directMemoryStart = {:#x}, alignment = {:#x}",
@@ -85,6 +86,16 @@ int PS4_SYSV_ABI sceKernelMapDirectMemory(void** addr, u64 len, int prot, int fl
                              directMemoryStart, alignment);
 }
 
+int PS4_SYSV_ABI sceKernelMapDirectMemory(void** addr, u64 len, int prot, int flags,
+                                          s64 directMemoryStart, u64 alignment) {
+    LOG_INFO(Kernel_Vmm,
+             "redirected to sceKernelMapNamedDirectMemory: "
+             "len = {:#x}, prot = {:#x}, flags = {:#x}, directMemoryStart = {:#x}, alignment = "
+             "{:#x}",
+             len, prot, flags, directMemoryStart, alignment);
+    return sceKernelMapNamedDirectMemory(addr, len, prot, flags, directMemoryStart, alignment, "");
+}
+
 s32 PS4_SYSV_ABI sceKernelMapNamedFlexibleMemory(void** addr_in_out, std::size_t len, int prot,
                                                  int flags, const char* name) {
 

src/core/libraries/kernel/memory_management.h

@@ -39,6 +39,9 @@ struct OrbisQueryInfo {
 u64 PS4_SYSV_ABI sceKernelGetDirectMemorySize();
 int PS4_SYSV_ABI sceKernelAllocateDirectMemory(s64 searchStart, s64 searchEnd, u64 len,
                                                u64 alignment, int memoryType, s64* physAddrOut);
+int PS4_SYSV_ABI sceKernelMapNamedDirectMemory(void** addr, u64 len, int prot, int flags,
+                                               s64 directMemoryStart, u64 alignment,
+                                               const char* name);
 int PS4_SYSV_ABI sceKernelMapDirectMemory(void** addr, u64 len, int prot, int flags,
                                           s64 directMemoryStart, u64 alignment);
 s32 PS4_SYSV_ABI sceKernelAllocateMainDirectMemory(size_t len, size_t alignment, int memoryType,

src/core/libraries/kernel/thread_management.cpp

@@ -14,6 +14,7 @@
 #ifdef _WIN64
 #include <windows.h>
 #endif
+#include "core/libraries/kernel/threads/kernel_threads.h"
 
 namespace Libraries::Kernel {
 
@@ -350,6 +351,28 @@ int PS4_SYSV_ABI scePthreadAttrSetstacksize(ScePthreadAttr* attr, size_t stack_s
     return result == 0 ? SCE_OK : SCE_KERNEL_ERROR_EINVAL;
 }
 
+int PS4_SYSV_ABI posix_pthread_attr_init(ScePthreadAttr* attr) {
+    int result = scePthreadAttrInit(attr);
+    if (result < 0) {
+        int rt = result > SCE_KERNEL_ERROR_UNKNOWN && result <= SCE_KERNEL_ERROR_ESTOP
+                     ? result + -SCE_KERNEL_ERROR_UNKNOWN
+                     : POSIX_EOTHER;
+        return rt;
+    }
+    return result;
+}
+
+int PS4_SYSV_ABI posix_pthread_attr_setstacksize(ScePthreadAttr* attr, size_t stacksize) {
+    int result = scePthreadAttrSetstacksize(attr, stacksize);
+    if (result < 0) {
+        int rt = result > SCE_KERNEL_ERROR_UNKNOWN && result <= SCE_KERNEL_ERROR_ESTOP
+                     ? result + -SCE_KERNEL_ERROR_UNKNOWN
+                     : POSIX_EOTHER;
+        return rt;
+    }
+    return result;
+}
+
 int PS4_SYSV_ABI scePthreadSetaffinity(ScePthread thread, const /*SceKernelCpumask*/ u64 mask) {
     LOG_INFO(Kernel_Pthread, "called");
 
@@ -666,6 +689,24 @@ int PS4_SYSV_ABI scePthreadCondTimedwait(ScePthreadCond* cond, ScePthreadMutex*
     }
 }
 
+int PS4_SYSV_ABI scePthreadCondDestroy(ScePthreadCond* cond) {
+    if (cond == nullptr) {
+        return SCE_KERNEL_ERROR_EINVAL;
+    }
+    int result = pthread_cond_destroy(&(*cond)->cond);
+
+    LOG_INFO(Kernel_Pthread, "scePthreadCondDestroy, result={}", result);
+
+    switch (result) {
+    case 0:
+        return SCE_OK;
+    case EBUSY:
+        return SCE_KERNEL_ERROR_EBUSY;
+    default:
+        return SCE_KERNEL_ERROR_EINVAL;
+    }
+}
+
 int PS4_SYSV_ABI posix_pthread_mutex_init(ScePthreadMutex* mutex, const ScePthreadMutexattr* attr) {
     // LOG_INFO(Kernel_Pthread, "posix pthread_mutex_init redirect to scePthreadMutexInit");
     int result = scePthreadMutexInit(mutex, attr, nullptr);
@@ -702,6 +743,25 @@ int PS4_SYSV_ABI posix_pthread_mutex_unlock(ScePthreadMutex* mutex) {
     return result;
 }
 
+int PS4_SYSV_ABI posix_pthread_mutex_destroy(ScePthreadMutex* mutex) {
+    int result = scePthreadMutexDestroy(mutex);
+    if (result < 0) {
+        int rt = result > SCE_KERNEL_ERROR_UNKNOWN && result <= SCE_KERNEL_ERROR_ESTOP
+                     ? result + -SCE_KERNEL_ERROR_UNKNOWN
+                     : POSIX_EOTHER;
+        return rt;
+    }
+    return result;
+}
+
+int PS4_SYSV_ABI posix_pthread_cond_wait(ScePthreadCond* cond, ScePthreadMutex* mutex) {
+    int result = scePthreadCondWait(cond, mutex);
+    if (result < 0) {
+        UNREACHABLE();
+    }
+    return result;
+}
+
 int PS4_SYSV_ABI posix_pthread_cond_broadcast(ScePthreadCond* cond) {
     LOG_INFO(Kernel_Pthread,
              "posix posix_pthread_cond_broadcast redirect to scePthreadCondBroadcast");
@@ -715,6 +775,47 @@ int PS4_SYSV_ABI posix_pthread_cond_broadcast(ScePthreadCond* cond) {
     return result;
 }
 
+int PS4_SYSV_ABI posix_pthread_mutexattr_init(ScePthreadMutexattr* attr) {
+    // LOG_INFO(Kernel_Pthread, "posix pthread_mutexattr_init redirect to scePthreadMutexattrInit");
+    int result = scePthreadMutexattrInit(attr);
+    if (result < 0) {
+        int rt = result > SCE_KERNEL_ERROR_UNKNOWN && result <= SCE_KERNEL_ERROR_ESTOP
+                     ? result + -SCE_KERNEL_ERROR_UNKNOWN
+                     : POSIX_EOTHER;
+        return rt;
+    }
+    return result;
+}
+
+int PS4_SYSV_ABI posix_pthread_mutexattr_settype(ScePthreadMutexattr* attr, int type) {
+    // LOG_INFO(Kernel_Pthread, "posix pthread_mutex_init redirect to scePthreadMutexInit");
+    int result = scePthreadMutexattrSettype(attr, type);
+    if (result < 0) {
+        int rt = result > SCE_KERNEL_ERROR_UNKNOWN && result <= SCE_KERNEL_ERROR_ESTOP
+                     ? result + -SCE_KERNEL_ERROR_UNKNOWN
+                     : POSIX_EOTHER;
+        return rt;
+    }
+    return result;
+}
+
+int PS4_SYSV_ABI posix_pthread_mutexattr_destroy(ScePthreadMutexattr* attr) {
+    int result = scePthreadMutexattrDestroy(attr);
+    if (result < 0) {
+        UNREACHABLE();
+    }
+    return result;
+}
+
+int PS4_SYSV_ABI posix_pthread_mutexattr_setprotocol(ScePthreadMutexattr* attr, int protocol) {
+    int result = scePthreadMutexattrSetprotocol(attr, protocol);
+    LOG_INFO(Kernel_Pthread, "redirect to scePthreadMutexattrSetprotocol: result = {}", result);
+    if (result < 0) {
+        UNREACHABLE();
+    }
+    return result;
+}
+
 int PS4_SYSV_ABI sceKernelClockGettime(s32 clock_id, SceKernelTimespec* tp) {
     if (tp == nullptr) {
         return SCE_KERNEL_ERROR_EFAULT;
@@ -928,13 +1029,38 @@ void PS4_SYSV_ABI scePthreadYield() {
     sched_yield();
 }
 
+int PS4_SYSV_ABI scePthreadAttrGetstack(ScePthreadAttr* attr, void** addr, size_t* size) {
+
+    int result = pthread_attr_getstack(&(*attr)->pth_attr, addr, size);
+    LOG_INFO(Kernel_Pthread, "scePthreadAttrGetstack: result = {}", result);
+
+    if (result == 0) {
+        return SCE_OK;
+    }
+    return SCE_KERNEL_ERROR_EINVAL;
+}
+
+int PS4_SYSV_ABI scePthreadJoin(ScePthread thread, void** res) {
+    int result = pthread_join(thread->pth, res);
+    LOG_INFO(Kernel_Pthread, "scePthreadJoin result = {}", result);
+    thread->is_detached = false;
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI posix_pthread_join(ScePthread thread, void** res) {
+    int result = pthread_join(thread->pth, res);
+    LOG_INFO(Kernel_Pthread, "posix_pthread_join result = {}", result);
+    thread->is_detached = false;
+    return ORBIS_OK;
+}
+
 int PS4_SYSV_ABI scePthreadDetach(ScePthread thread) {
     LOG_INFO(Kernel_Pthread, "thread create name = {}", thread->name);
     thread->is_detached = true;
     return ORBIS_OK;
 }
 
-ScePthread PS4_SYSV_ABI pthread_self() {
+ScePthread PS4_SYSV_ABI posix_pthread_self() {
     return g_pthread_self;
 }
 
@@ -1026,6 +1152,10 @@ int PS4_SYSV_ABI scePthreadEqual(ScePthread thread1, ScePthread thread2) {
     return (thread1 == thread2 ? 1 : 0);
 }
 
+int PS4_SYSV_ABI posix_pthread_equal(ScePthread thread1, ScePthread thread2) {
+    return (thread1 == thread2 ? 1 : 0);
+}
+
 struct TlsIndex {
     u64 ti_module;
     u64 ti_offset;
@@ -1036,6 +1166,60 @@ void* PS4_SYSV_ABI __tls_get_addr(TlsIndex* index) {
     return linker->TlsGetAddr(index->ti_module, index->ti_offset);
 }
 
+int PS4_SYSV_ABI posix_sched_get_priority_max() {
+    return ORBIS_KERNEL_PRIO_FIFO_HIGHEST;
+}
+
+int PS4_SYSV_ABI posix_sched_get_priority_min() {
+    return ORBIS_KERNEL_PRIO_FIFO_LOWEST;
+}
+
+int PS4_SYSV_ABI posix_pthread_mutex_trylock(ScePthreadMutex* mutex) {
+    int result = scePthreadMutexTrylock(mutex);
+    if (result < 0) {
+        UNREACHABLE();
+    }
+    return result;
+}
+
+int PS4_SYSV_ABI posix_pthread_attr_destroy(ScePthreadAttr* attr) {
+    int result = scePthreadAttrDestroy(attr);
+    if (result < 0) {
+        int rt = result > SCE_KERNEL_ERROR_UNKNOWN && result <= SCE_KERNEL_ERROR_ESTOP
+                     ? result + -SCE_KERNEL_ERROR_UNKNOWN
+                     : POSIX_EOTHER;
+        return rt;
+    }
+    return result;
+}
+
+int PS4_SYSV_ABI posix_pthread_attr_setdetachstate(ScePthreadAttr* attr, int detachstate) {
+    // LOG_INFO(Kernel_Pthread, "posix pthread_mutexattr_init redirect to scePthreadMutexattrInit");
+    int result = scePthreadAttrSetdetachstate(attr, detachstate);
+    if (result < 0) {
+        int rt = result > SCE_KERNEL_ERROR_UNKNOWN && result <= SCE_KERNEL_ERROR_ESTOP
+                     ? result + -SCE_KERNEL_ERROR_UNKNOWN
+                     : POSIX_EOTHER;
+        return rt;
+    }
+    return result;
+}
+
+int PS4_SYSV_ABI posix_pthread_create_name_np(ScePthread* thread, const ScePthreadAttr* attr,
+                                              pthreadEntryFunc start_routine, void* arg,
+                                              const char* name) {
+    LOG_INFO(Kernel_Pthread, "posix pthread_create redirect to scePthreadCreate: name = {}", name);
+
+    int result = scePthreadCreate(thread, attr, start_routine, arg, name);
+    if (result != 0) {
+        int rt = result > SCE_KERNEL_ERROR_UNKNOWN && result <= SCE_KERNEL_ERROR_ESTOP
+                     ? result + -SCE_KERNEL_ERROR_UNKNOWN
+                     : POSIX_EOTHER;
+        return rt;
+    }
+    return result;
+}
+
 void pthreadSymbolsRegister(Core::Loader::SymbolsResolver* sym) {
     LIB_FUNCTION("4+h9EzwKF4I", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrSetschedpolicy);
     LIB_FUNCTION("-Wreprtu0Qs", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrSetdetachstate);
@@ -1043,11 +1227,15 @@ void pthreadSymbolsRegister(Core::Loader::SymbolsResolver* sym) {
     LIB_FUNCTION("DzES9hQF4f4", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrSetschedparam);
     LIB_FUNCTION("nsYoNRywwNg", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrInit);
     LIB_FUNCTION("62KCwEMmzcM", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrDestroy);
+    LIB_FUNCTION("onNY9Byn-W8", "libkernel", 1, "libkernel", 1, 1, scePthreadJoin);
     LIB_FUNCTION("4qGrR6eoP9Y", "libkernel", 1, "libkernel", 1, 1, scePthreadDetach);
     LIB_FUNCTION("3PtV6p3QNX4", "libkernel", 1, "libkernel", 1, 1, scePthreadEqual);
+    LIB_FUNCTION("7Xl257M4VNI", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_equal);
+    LIB_FUNCTION("7Xl257M4VNI", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_join);
 
     LIB_FUNCTION("aI+OeCz8xrQ", "libkernel", 1, "libkernel", 1, 1, scePthreadSelf);
-    LIB_FUNCTION("EotR8a3ASf4", "libkernel", 1, "libkernel", 1, 1, pthread_self);
+    LIB_FUNCTION("EotR8a3ASf4", "libkernel", 1, "libkernel", 1, 1, posix_pthread_self);
+    LIB_FUNCTION("EotR8a3ASf4", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_self);
     LIB_FUNCTION("3qxgM4ezETA", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrSetaffinity);
     LIB_FUNCTION("8+s5BzZjxSg", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrGetaffinity);
     LIB_FUNCTION("x1X76arYMxU", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrGet);
@@ -1057,6 +1245,7 @@ void pthreadSymbolsRegister(Core::Loader::SymbolsResolver* sym) {
     LIB_FUNCTION("bt3CTBKmGyI", "libkernel", 1, "libkernel", 1, 1, scePthreadSetaffinity);
     LIB_FUNCTION("6UgtwV+0zb4", "libkernel", 1, "libkernel", 1, 1, scePthreadCreate);
     LIB_FUNCTION("T72hz6ffq08", "libkernel", 1, "libkernel", 1, 1, scePthreadYield);
+    LIB_FUNCTION("-quPa4SEJUw", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrGetstack);
 
     // mutex calls
     LIB_FUNCTION("cmo1RIYva9o", "libkernel", 1, "libkernel", 1, 1, scePthreadMutexInit);
@@ -1076,12 +1265,25 @@ void pthreadSymbolsRegister(Core::Loader::SymbolsResolver* sym) {
     LIB_FUNCTION("waPcxYiR3WA", "libkernel", 1, "libkernel", 1, 1, scePthreadCondattrDestroy);
     LIB_FUNCTION("kDh-NfxgMtE", "libkernel", 1, "libkernel", 1, 1, scePthreadCondSignal);
     LIB_FUNCTION("BmMjYxmew1w", "libkernel", 1, "libkernel", 1, 1, scePthreadCondTimedwait);
+    LIB_FUNCTION("g+PZd2hiacg", "libkernel", 1, "libkernel", 1, 1, scePthreadCondDestroy);
+
     // posix calls
+    LIB_FUNCTION("wtkt-teR1so", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_attr_init);
+    LIB_FUNCTION("2Q0z6rnBrTE", "libScePosix", 1, "libkernel", 1, 1,
+                 posix_pthread_attr_setstacksize);
     LIB_FUNCTION("ttHNfU+qDBU", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_mutex_init);
     LIB_FUNCTION("7H0iTOciTLo", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_mutex_lock);
     LIB_FUNCTION("2Z+PpY6CaJg", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_mutex_unlock);
+    LIB_FUNCTION("ltCfaGr2JGE", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_mutex_destroy);
+    LIB_FUNCTION("Op8TBGY5KHg", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_cond_wait);
     LIB_FUNCTION("mkx2fVhNMsg", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_cond_broadcast);
-
+    LIB_FUNCTION("dQHWEsJtoE4", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_mutexattr_init);
+    LIB_FUNCTION("mDmgMOGVUqg", "libScePosix", 1, "libkernel", 1, 1,
+                 posix_pthread_mutexattr_settype);
+    LIB_FUNCTION("5txKfcMUAok", "libScePosix", 1, "libkernel", 1, 1,
+                 posix_pthread_mutexattr_setprotocol);
+    LIB_FUNCTION("HF7lK46xzjY", "libScePosix", 1, "libkernel", 1, 1,
+                 posix_pthread_mutexattr_destroy);
     LIB_FUNCTION("QBi7HCK03hw", "libkernel", 1, "libkernel", 1, 1, sceKernelClockGettime);
     LIB_FUNCTION("lLMT9vJAck0", "libkernel", 1, "libkernel", 1, 1, clock_gettime);
     LIB_FUNCTION("lLMT9vJAck0", "libScePosix", 1, "libkernel", 1, 1, clock_gettime);
@@ -1091,6 +1293,15 @@ void pthreadSymbolsRegister(Core::Loader::SymbolsResolver* sym) {
     LIB_FUNCTION("7H0iTOciTLo", "libkernel", 1, "libkernel", 1, 1, posix_pthread_mutex_lock);
     LIB_FUNCTION("2Z+PpY6CaJg", "libkernel", 1, "libkernel", 1, 1, posix_pthread_mutex_unlock);
     LIB_FUNCTION("mkx2fVhNMsg", "libkernel", 1, "libkernel", 1, 1, posix_pthread_cond_broadcast);
+    LIB_FUNCTION("K-jXhbt2gn4", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_mutex_trylock);
+    LIB_FUNCTION("E+tyo3lp5Lw", "libScePosix", 1, "libkernel", 1, 1,
+                 posix_pthread_attr_setdetachstate);
+    LIB_FUNCTION("zHchY8ft5pk", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_attr_destroy);
+    LIB_FUNCTION("Jmi+9w9u0E4", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_create_name_np);
+    LIB_FUNCTION("CBNtXOoef-E", "libScePosix", 1, "libkernel", 1, 1, posix_sched_get_priority_max);
+    LIB_FUNCTION("m0iS6jNsXds", "libScePosix", 1, "libkernel", 1, 1, posix_sched_get_priority_min);
+    // libs
+    ThreadsRwlockSymbolsRegister(sym);
 }
 
 } // namespace Libraries::Kernel

src/core/libraries/kernel/thread_management.h

@@ -16,6 +16,9 @@ class SymbolsResolver;
 }
 
 namespace Libraries::Kernel {
+constexpr int ORBIS_KERNEL_PRIO_FIFO_DEFAULT = 700;
+constexpr int ORBIS_KERNEL_PRIO_FIFO_HIGHEST = 256;
+constexpr int ORBIS_KERNEL_PRIO_FIFO_LOWEST = 767;
 
 struct PthreadInternal;
 struct PthreadAttrInternal;
@@ -23,6 +26,8 @@ struct PthreadMutexInternal;
 struct PthreadMutexattrInternal;
 struct PthreadCondInternal;
 struct PthreadCondAttrInternal;
+struct PthreadRwInternal;
+struct PthreadRwLockAttrInernal;
 
 using SceKernelSchedParam = ::sched_param;
 using ScePthread = PthreadInternal*;
@@ -31,6 +36,8 @@ using ScePthreadMutex = PthreadMutexInternal*;
 using ScePthreadMutexattr = PthreadMutexattrInternal*;
 using ScePthreadCond = PthreadCondInternal*;
 using ScePthreadCondattr = PthreadCondAttrInternal*;
+using OrbisPthreadRwlock = PthreadRwInternal*;
+using OrbisPthreadRwlockattr = PthreadRwLockAttrInernal*;
 
 using pthreadEntryFunc = PS4_SYSV_ABI void* (*)(void*);
 
@@ -84,6 +91,17 @@ struct PthreadCondAttrInternal {
     pthread_condattr_t cond_attr;
 };
 
+struct PthreadRwLockAttrInernal {
+    u8 reserved[64];
+    pthread_rwlockattr_t attr_rwlock;
+    int type;
+};
+
+struct PthreadRwInternal {
+    pthread_rwlock_t pth_rwlock;
+    std::string name;
+};
+
 class PThreadPool {
 public:
     ScePthread Create();
@@ -119,12 +137,19 @@ public:
     void SetPthreadPool(PThreadPool* pool) {
         m_pthread_pool = pool;
     }
+    OrbisPthreadRwlockattr* getDefaultRwattr() {
+        return &m_default_Rwattr;
+    }
+    void setDefaultRwattr(OrbisPthreadRwlockattr attr) {
+        m_default_Rwattr = attr;
+    }
 
 private:
     ScePthreadMutexattr m_default_mutexattr = nullptr;
     ScePthreadCondattr m_default_condattr = nullptr;
     ScePthreadAttr m_default_attr = nullptr;
     PThreadPool* m_pthread_pool = nullptr;
+    OrbisPthreadRwlockattr m_default_Rwattr = nullptr;
 };
 
 void init_pthreads();
@@ -160,6 +185,7 @@ int PS4_SYSV_ABI scePthreadCondInit(ScePthreadCond* cond, const ScePthreadCondat
                                     const char* name);
 int PS4_SYSV_ABI scePthreadCondattrInit(ScePthreadCondattr* attr);
 int PS4_SYSV_ABI scePthreadCondBroadcast(ScePthreadCond* cond);
+int PS4_SYSV_ABI scePthreadCondWait(ScePthreadCond* cond, ScePthreadMutex* mutex);
 /****
  * Posix calls
  */

src/core/libraries/kernel/threads/kernel_threads.h

@@ -0,0 +1,53 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "core/libraries/kernel/thread_management.h"
+
+namespace Core::Loader {
+class SymbolsResolver;
+}
+
+namespace Libraries::Kernel {
+/****
+ * rwlock calls
+ */
+int PS4_SYSV_ABI posix_pthread_rwlock_destroy(OrbisPthreadRwlock* rwlock);
+int PS4_SYSV_ABI posix_pthread_rwlock_init(OrbisPthreadRwlock* rwlock,
+                                           const OrbisPthreadRwlockattr* attr, const char* name);
+int PS4_SYSV_ABI posix_pthread_rwlock_rdlock(OrbisPthreadRwlock* rwlock);
+int PS4_SYSV_ABI posix_pthread_rwlock_reltimedrdlock_np();
+int PS4_SYSV_ABI posix_pthread_rwlock_reltimedwrlock_np();
+int PS4_SYSV_ABI posix_pthread_rwlock_setname_np();
+int PS4_SYSV_ABI posix_pthread_rwlock_timedrdlock();
+int PS4_SYSV_ABI posix_pthread_rwlock_timedwrlock();
+int PS4_SYSV_ABI posix_pthread_rwlock_tryrdlock(OrbisPthreadRwlock* rwlock);
+int PS4_SYSV_ABI posix_pthread_rwlock_trywrlock(OrbisPthreadRwlock* rwlock);
+int PS4_SYSV_ABI posix_pthread_rwlock_unlock(OrbisPthreadRwlock* rwlock);
+int PS4_SYSV_ABI posix_pthread_rwlock_wrlock(OrbisPthreadRwlock* rwlock);
+int PS4_SYSV_ABI posix_pthread_rwlockattr_destroy(OrbisPthreadRwlockattr* attr);
+int PS4_SYSV_ABI posix_pthread_rwlockattr_getpshared();
+int PS4_SYSV_ABI posix_pthread_rwlockattr_gettype_np();
+int PS4_SYSV_ABI posix_pthread_rwlockattr_init(OrbisPthreadRwlockattr* attr);
+int PS4_SYSV_ABI posix_pthread_rwlockattr_setpshared();
+int PS4_SYSV_ABI posix_pthread_rwlockattr_settype_np();
+int PS4_SYSV_ABI scePthreadRwlockattrDestroy(OrbisPthreadRwlockattr* attr);
+int PS4_SYSV_ABI scePthreadRwlockattrGetpshared();
+int PS4_SYSV_ABI scePthreadRwlockattrGettype();
+int PS4_SYSV_ABI scePthreadRwlockattrInit(OrbisPthreadRwlockattr* attr);
+int PS4_SYSV_ABI scePthreadRwlockattrSetpshared();
+int PS4_SYSV_ABI scePthreadRwlockattrSettype();
+int PS4_SYSV_ABI scePthreadRwlockDestroy(OrbisPthreadRwlock* rwlock);
+int PS4_SYSV_ABI scePthreadRwlockInit(OrbisPthreadRwlock* rwlock,
+                                      const OrbisPthreadRwlockattr* attr, const char* name);
+int PS4_SYSV_ABI scePthreadRwlockRdlock(OrbisPthreadRwlock* rwlock);
+int PS4_SYSV_ABI scePthreadRwlockTimedrdlock();
+int PS4_SYSV_ABI scePthreadRwlockTimedwrlock();
+int PS4_SYSV_ABI scePthreadRwlockTryrdlock(OrbisPthreadRwlock* rwlock);
+int PS4_SYSV_ABI scePthreadRwlockTrywrlock(OrbisPthreadRwlock* rwlock);
+int PS4_SYSV_ABI scePthreadRwlockUnlock(OrbisPthreadRwlock* rwlock);
+int PS4_SYSV_ABI scePthreadRwlockWrlock(OrbisPthreadRwlock* rwlock);
+
+void ThreadsRwlockSymbolsRegister(Core::Loader::SymbolsResolver* sym);
+} // namespace Libraries::Kernel

src/core/libraries/kernel/threads/kernel_threads_rwlock.cpp

@@ -0,0 +1,351 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "common/logging/log.h"
+#include "core/libraries/error_codes.h"
+#include "core/libraries/libs.h"
+#include "kernel_threads.h"
+
+namespace Libraries::Kernel {
+
+extern PThreadCxt* g_pthread_cxt;
+
+int PS4_SYSV_ABI posix_pthread_rwlock_destroy(OrbisPthreadRwlock* rwlock) {
+    int result = pthread_rwlock_destroy(&(*rwlock)->pth_rwlock);
+    delete *rwlock;
+    *rwlock = nullptr;
+    if (result != 0) {
+        LOG_ERROR(Kernel_Pthread, "posix_pthread_rwlock_destroy: error = {}", result);
+        result += ORBIS_KERNEL_ERROR_UNKNOWN;
+    }
+    return result;
+}
+
+int PS4_SYSV_ABI posix_pthread_rwlock_init(OrbisPthreadRwlock* rwlock,
+                                           const OrbisPthreadRwlockattr* attr, const char* name) {
+    *rwlock = new PthreadRwInternal{};
+    if (attr == nullptr || *attr == nullptr) {
+        attr = g_pthread_cxt->getDefaultRwattr();
+    }
+    int result = pthread_rwlock_init(&(*rwlock)->pth_rwlock, &(*attr)->attr_rwlock);
+    if (result != 0) {
+        LOG_ERROR(Kernel_Pthread, "posix_pthread_rwlock_init: error = {}", result);
+    }
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI posix_pthread_rwlock_rdlock(OrbisPthreadRwlock* rwlock) {
+    int result = pthread_rwlock_rdlock(&(*rwlock)->pth_rwlock);
+    if (result != 0) {
+        LOG_ERROR(Kernel_Pthread, "posix_pthread_rwlock_rdlock: error = {}", result);
+        result += ORBIS_KERNEL_ERROR_UNKNOWN;
+    }
+    return result;
+}
+
+int PS4_SYSV_ABI posix_pthread_rwlock_reltimedrdlock_np() {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI posix_pthread_rwlock_reltimedwrlock_np() {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI posix_pthread_rwlock_setname_np() {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI posix_pthread_rwlock_timedrdlock() {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI posix_pthread_rwlock_timedwrlock() {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI posix_pthread_rwlock_tryrdlock(OrbisPthreadRwlock* rwlock) {
+    int result = pthread_rwlock_tryrdlock(&(*rwlock)->pth_rwlock);
+    if (result != 0) {
+        LOG_ERROR(Kernel_Pthread, "posix_pthread_rwlock_tryrdlock: error = {}", result);
+    }
+    return result;
+}
+
+int PS4_SYSV_ABI posix_pthread_rwlock_trywrlock(OrbisPthreadRwlock* rwlock) {
+    int result = pthread_rwlock_trywrlock(&(*rwlock)->pth_rwlock);
+    if (result != 0) {
+        LOG_ERROR(Kernel_Pthread, "posix_pthread_rwlock_trywrlock: error = {}", result);
+    }
+    return result;
+}
+
+int PS4_SYSV_ABI posix_pthread_rwlock_unlock(OrbisPthreadRwlock* rwlock) {
+    int result = pthread_rwlock_unlock(&(*rwlock)->pth_rwlock);
+    if (result != 0) {
+        LOG_ERROR(Kernel_Pthread, "posix_pthread_rwlock_unlock: error = {}", result);
+    }
+    return result;
+}
+
+int PS4_SYSV_ABI posix_pthread_rwlock_wrlock(OrbisPthreadRwlock* rwlock) {
+    int result = pthread_rwlock_wrlock(&(*rwlock)->pth_rwlock);
+    if (result != 0) {
+        LOG_ERROR(Kernel_Pthread, "posix_pthread_rwlock_wrlock: error = {}", result);
+    }
+    return result;
+}
+
+int PS4_SYSV_ABI posix_pthread_rwlockattr_destroy(OrbisPthreadRwlockattr* attr) {
+    int result = pthread_rwlockattr_destroy(&(*attr)->attr_rwlock);
+    delete *attr;
+    *attr = nullptr;
+    if (result != 0) {
+        LOG_ERROR(Kernel_Pthread, "posix_pthread_rwlockattr_destroy: error = {}", result);
+    }
+    return result;
+}
+
+int PS4_SYSV_ABI posix_pthread_rwlockattr_getpshared() {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI posix_pthread_rwlockattr_gettype_np() {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI posix_pthread_rwlockattr_init(OrbisPthreadRwlockattr* attr) {
+    *attr = new PthreadRwLockAttrInernal{};
+    int result = pthread_rwlockattr_init(&(*attr)->attr_rwlock);
+    if (result != 0) {
+        LOG_ERROR(Kernel_Pthread, "posix_pthread_rwlockattr_init: error = {}", result);
+    }
+    return result;
+}
+
+int PS4_SYSV_ABI posix_pthread_rwlockattr_setpshared() {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI posix_pthread_rwlockattr_settype_np() {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI scePthreadRwlockattrDestroy(OrbisPthreadRwlockattr* attr) {
+    int result = pthread_rwlockattr_destroy(&(*attr)->attr_rwlock);
+    delete *attr;
+    *attr = nullptr;
+    if (result != 0) {
+        LOG_ERROR(Kernel_Pthread, "scePthreadRwlockattrDestroy: error = {}", result);
+        result += ORBIS_KERNEL_ERROR_UNKNOWN;
+    }
+    return result;
+}
+
+int PS4_SYSV_ABI scePthreadRwlockattrGetpshared() {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI scePthreadRwlockattrGettype() {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI scePthreadRwlockattrInit(OrbisPthreadRwlockattr* attr) {
+    *attr = new PthreadRwLockAttrInernal{};
+    int result = pthread_rwlockattr_init(&(*attr)->attr_rwlock);
+    if (result != 0) {
+        LOG_ERROR(Kernel_Pthread, "scePthreadRwlockattrInit: error = {}", result);
+        result += ORBIS_KERNEL_ERROR_UNKNOWN;
+    }
+    return result;
+}
+
+int PS4_SYSV_ABI scePthreadRwlockattrSetpshared() {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI scePthreadRwlockattrSettype() {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI scePthreadRwlockDestroy(OrbisPthreadRwlock* rwlock) {
+    int result = pthread_rwlock_destroy(&(*rwlock)->pth_rwlock);
+    delete *rwlock;
+    *rwlock = nullptr;
+    if (result != 0) {
+        LOG_ERROR(Kernel_Pthread, "scePthreadRwlockDestroy: error = {}", result);
+        result += ORBIS_KERNEL_ERROR_UNKNOWN;
+    }
+    return result;
+}
+
+int PS4_SYSV_ABI scePthreadRwlockInit(OrbisPthreadRwlock* rwlock,
+                                      const OrbisPthreadRwlockattr* attr, const char* name) {
+    *rwlock = new PthreadRwInternal{};
+    if (rwlock == nullptr || *rwlock == nullptr) {
+        return ORBIS_KERNEL_ERROR_EINVAL;
+    }
+
+    if (attr == nullptr || *attr == nullptr) {
+        attr = g_pthread_cxt->getDefaultRwattr();
+    }
+    (*rwlock)->name = name;
+    int result = pthread_rwlock_init(&(*rwlock)->pth_rwlock, &(*attr)->attr_rwlock);
+    if (result != 0) {
+        LOG_ERROR(Kernel_Pthread, "scePthreadRwlockInit: error = {}", result);
+        result += ORBIS_KERNEL_ERROR_UNKNOWN;
+    }
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI scePthreadRwlockRdlock(OrbisPthreadRwlock* rwlock) {
+    if (rwlock == nullptr || *rwlock == nullptr) {
+        return ORBIS_KERNEL_ERROR_EINVAL;
+    }
+    int result = pthread_rwlock_rdlock(&(*rwlock)->pth_rwlock);
+    if (result != 0) {
+        LOG_ERROR(Kernel_Pthread, "scePthreadRwlockRdlock: error = {}", result);
+        result += ORBIS_KERNEL_ERROR_UNKNOWN;
+    }
+    return result;
+}
+
+int PS4_SYSV_ABI scePthreadRwlockTimedrdlock() {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI scePthreadRwlockTimedwrlock() {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI scePthreadRwlockTryrdlock(OrbisPthreadRwlock* rwlock) {
+    if (rwlock == nullptr || *rwlock == nullptr) {
+        return ORBIS_KERNEL_ERROR_EINVAL;
+    }
+    int result = pthread_rwlock_tryrdlock(&(*rwlock)->pth_rwlock);
+    if (result != 0) {
+        LOG_ERROR(Kernel_Pthread, "scePthreadRwlockTryrdlock: error = {}", result);
+        result += ORBIS_KERNEL_ERROR_UNKNOWN;
+    }
+    return result;
+}
+
+int PS4_SYSV_ABI scePthreadRwlockTrywrlock(OrbisPthreadRwlock* rwlock) {
+    if (rwlock == nullptr || *rwlock == nullptr) {
+        return ORBIS_KERNEL_ERROR_EINVAL;
+    }
+    int result = pthread_rwlock_trywrlock(&(*rwlock)->pth_rwlock);
+    if (result != 0) {
+        LOG_ERROR(Kernel_Pthread, "scePthreadRwlockTrywrlock: error = {}", result);
+        result += ORBIS_KERNEL_ERROR_UNKNOWN;
+    }
+    return result;
+}
+
+int PS4_SYSV_ABI scePthreadRwlockUnlock(OrbisPthreadRwlock* rwlock) {
+    if (rwlock == nullptr || *rwlock == nullptr) {
+        return ORBIS_KERNEL_ERROR_EINVAL;
+    }
+    int result = pthread_rwlock_unlock(&(*rwlock)->pth_rwlock);
+    if (result != 0) {
+        LOG_ERROR(Kernel_Pthread, "scePthreadRwlockUnlock: error = {}", result);
+        result += ORBIS_KERNEL_ERROR_UNKNOWN;
+    }
+    return result;
+}
+
+int PS4_SYSV_ABI scePthreadRwlockWrlock(OrbisPthreadRwlock* rwlock) {
+    if (rwlock == nullptr || *rwlock == nullptr) {
+        return ORBIS_KERNEL_ERROR_EINVAL;
+    }
+    int result = pthread_rwlock_wrlock(&(*rwlock)->pth_rwlock);
+    if (result != 0) {
+        LOG_ERROR(Kernel_Pthread, "scePthreadRwlockWrlock: error = {}", result);
+        result += ORBIS_KERNEL_ERROR_UNKNOWN;
+    }
+    return result;
+}
+
+void ThreadsRwlockSymbolsRegister(Core::Loader::SymbolsResolver* sym) {
+    LIB_FUNCTION("1471ajPzxh0", "libkernel", 1, "libkernel", 1, 1, posix_pthread_rwlock_destroy);
+    LIB_FUNCTION("ytQULN-nhL4", "libkernel", 1, "libkernel", 1, 1, posix_pthread_rwlock_init);
+    LIB_FUNCTION("iGjsr1WAtI0", "libkernel", 1, "libkernel", 1, 1, posix_pthread_rwlock_rdlock);
+    LIB_FUNCTION("dYv-+If2GPk", "libkernel", 1, "libkernel", 1, 1,
+                 posix_pthread_rwlock_reltimedrdlock_np);
+    LIB_FUNCTION("RRnSj8h8VR4", "libkernel", 1, "libkernel", 1, 1,
+                 posix_pthread_rwlock_reltimedwrlock_np);
+    LIB_FUNCTION("Uwxgnsi3xeM", "libkernel", 1, "libkernel", 1, 1, posix_pthread_rwlock_setname_np);
+    LIB_FUNCTION("lb8lnYo-o7k", "libkernel", 1, "libkernel", 1, 1,
+                 posix_pthread_rwlock_timedrdlock);
+    LIB_FUNCTION("9zklzAl9CGM", "libkernel", 1, "libkernel", 1, 1,
+                 posix_pthread_rwlock_timedwrlock);
+    LIB_FUNCTION("SFxTMOfuCkE", "libkernel", 1, "libkernel", 1, 1, posix_pthread_rwlock_tryrdlock);
+    LIB_FUNCTION("XhWHn6P5R7U", "libkernel", 1, "libkernel", 1, 1, posix_pthread_rwlock_trywrlock);
+    LIB_FUNCTION("EgmLo6EWgso", "libkernel", 1, "libkernel", 1, 1, posix_pthread_rwlock_unlock);
+    LIB_FUNCTION("sIlRvQqsN2Y", "libkernel", 1, "libkernel", 1, 1, posix_pthread_rwlock_wrlock);
+    LIB_FUNCTION("qsdmgXjqSgk", "libkernel", 1, "libkernel", 1, 1,
+                 posix_pthread_rwlockattr_destroy);
+    LIB_FUNCTION("VqEMuCv-qHY", "libkernel", 1, "libkernel", 1, 1,
+                 posix_pthread_rwlockattr_getpshared);
+    LIB_FUNCTION("l+bG5fsYkhg", "libkernel", 1, "libkernel", 1, 1,
+                 posix_pthread_rwlockattr_gettype_np);
+    LIB_FUNCTION("xFebsA4YsFI", "libkernel", 1, "libkernel", 1, 1, posix_pthread_rwlockattr_init);
+    LIB_FUNCTION("OuKg+kRDD7U", "libkernel", 1, "libkernel", 1, 1,
+                 posix_pthread_rwlockattr_setpshared);
+    LIB_FUNCTION("8NuOHiTr1Vw", "libkernel", 1, "libkernel", 1, 1,
+                 posix_pthread_rwlockattr_settype_np);
+    LIB_FUNCTION("1471ajPzxh0", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_rwlock_destroy);
+    LIB_FUNCTION("ytQULN-nhL4", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_rwlock_init);
+    LIB_FUNCTION("iGjsr1WAtI0", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_rwlock_rdlock);
+    LIB_FUNCTION("lb8lnYo-o7k", "libScePosix", 1, "libkernel", 1, 1,
+                 posix_pthread_rwlock_timedrdlock);
+    LIB_FUNCTION("9zklzAl9CGM", "libScePosix", 1, "libkernel", 1, 1,
+                 posix_pthread_rwlock_timedwrlock);
+    LIB_FUNCTION("SFxTMOfuCkE", "libScePosix", 1, "libkernel", 1, 1,
+                 posix_pthread_rwlock_tryrdlock);
+    LIB_FUNCTION("XhWHn6P5R7U", "libScePosix", 1, "libkernel", 1, 1,
+                 posix_pthread_rwlock_trywrlock);
+    LIB_FUNCTION("EgmLo6EWgso", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_rwlock_unlock);
+    LIB_FUNCTION("sIlRvQqsN2Y", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_rwlock_wrlock);
+    LIB_FUNCTION("qsdmgXjqSgk", "libScePosix", 1, "libkernel", 1, 1,
+                 posix_pthread_rwlockattr_destroy);
+    LIB_FUNCTION("VqEMuCv-qHY", "libScePosix", 1, "libkernel", 1, 1,
+                 posix_pthread_rwlockattr_getpshared);
+    LIB_FUNCTION("l+bG5fsYkhg", "libScePosix", 1, "libkernel", 1, 1,
+                 posix_pthread_rwlockattr_gettype_np);
+    LIB_FUNCTION("xFebsA4YsFI", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_rwlockattr_init);
+    LIB_FUNCTION("OuKg+kRDD7U", "libScePosix", 1, "libkernel", 1, 1,
+                 posix_pthread_rwlockattr_setpshared);
+    LIB_FUNCTION("8NuOHiTr1Vw", "libScePosix", 1, "libkernel", 1, 1,
+                 posix_pthread_rwlockattr_settype_np);
+    LIB_FUNCTION("i2ifZ3fS2fo", "libkernel", 1, "libkernel", 1, 1, scePthreadRwlockattrDestroy);
+    LIB_FUNCTION("LcOZBHGqbFk", "libkernel", 1, "libkernel", 1, 1, scePthreadRwlockattrGetpshared);
+    LIB_FUNCTION("Kyls1ChFyrc", "libkernel", 1, "libkernel", 1, 1, scePthreadRwlockattrGettype);
+    LIB_FUNCTION("yOfGg-I1ZII", "libkernel", 1, "libkernel", 1, 1, scePthreadRwlockattrInit);
+    LIB_FUNCTION("-ZvQH18j10c", "libkernel", 1, "libkernel", 1, 1, scePthreadRwlockattrSetpshared);
+    LIB_FUNCTION("h-OifiouBd8", "libkernel", 1, "libkernel", 1, 1, scePthreadRwlockattrSettype);
+    LIB_FUNCTION("BB+kb08Tl9A", "libkernel", 1, "libkernel", 1, 1, scePthreadRwlockDestroy);
+    LIB_FUNCTION("6ULAa0fq4jA", "libkernel", 1, "libkernel", 1, 1, scePthreadRwlockInit);
+    LIB_FUNCTION("Ox9i0c7L5w0", "libkernel", 1, "libkernel", 1, 1, scePthreadRwlockRdlock);
+    LIB_FUNCTION("iPtZRWICjrM", "libkernel", 1, "libkernel", 1, 1, scePthreadRwlockTimedrdlock);
+    LIB_FUNCTION("adh--6nIqTk", "libkernel", 1, "libkernel", 1, 1, scePthreadRwlockTimedwrlock);
+    LIB_FUNCTION("XD3mDeybCnk", "libkernel", 1, "libkernel", 1, 1, scePthreadRwlockTryrdlock);
+    LIB_FUNCTION("bIHoZCTomsI", "libkernel", 1, "libkernel", 1, 1, scePthreadRwlockTrywrlock);
+    LIB_FUNCTION("+L98PIbGttk", "libkernel", 1, "libkernel", 1, 1, scePthreadRwlockUnlock);
+    LIB_FUNCTION("mqdNorrB+gI", "libkernel", 1, "libkernel", 1, 1, scePthreadRwlockWrlock);
+}
+} // namespace Libraries::Kernel

src/core/libraries/libs.cpp

@@ -5,6 +5,7 @@
 #include "core/libraries/app_content/app_content.h"
 #include "core/libraries/audio/audioin.h"
 #include "core/libraries/audio/audioout.h"
+#include "core/libraries/disc_map/disc_map.h"
 #include "core/libraries/gnmdriver/gnmdriver.h"
 #include "core/libraries/kernel/libkernel.h"
 #include "core/libraries/libc/libc.h"
@@ -18,6 +19,7 @@
 #include "core/libraries/np_score/np_score.h"
 #include "core/libraries/np_trophy/np_trophy.h"
 #include "core/libraries/pad/pad.h"
+#include "core/libraries/rtc/rtc.h"
 #include "core/libraries/save_data/savedata.h"
 #include "core/libraries/screenshot/screenshot.h"
 #include "core/libraries/system/commondialog.h"
@@ -61,6 +63,8 @@ void InitHLELibs(Core::Loader::SymbolsResolver* sym) {
     Libraries::ScreenShot::RegisterlibSceScreenShot(sym);
     Libraries::LibcInternal::RegisterlibSceLibcInternal(sym);
     Libraries::AppContent::RegisterlibSceAppContent(sym);
+    Libraries::Rtc::RegisterlibSceRtc(sym);
+    Libraries::DiscMap::RegisterlibSceDiscMap(sym);
 }
 
 } // namespace Libraries

src/core/libraries/rtc/rtc.cpp

@@ -0,0 +1,303 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+// Generated By moduleGenerator
+#include <chrono>
+#include "common/logging/log.h"
+#include "core/libraries/error_codes.h"
+#include "core/libraries/libs.h"
+#include "rtc.h"
+
+namespace Libraries::Rtc {
+
+int PS4_SYSV_ABI sceRtcCheckValid() {
+    LOG_ERROR(Lib_Rtc, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRtcCompareTick() {
+    LOG_ERROR(Lib_Rtc, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRtcConvertLocalTimeToUtc() {
+    LOG_ERROR(Lib_Rtc, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRtcConvertUtcToLocalTime() {
+    LOG_ERROR(Lib_Rtc, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRtcEnd() {
+    LOG_ERROR(Lib_Rtc, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRtcFormatRFC2822() {
+    LOG_ERROR(Lib_Rtc, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRtcFormatRFC2822LocalTime() {
+    LOG_ERROR(Lib_Rtc, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRtcFormatRFC3339() {
+    LOG_ERROR(Lib_Rtc, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRtcFormatRFC3339LocalTime() {
+    LOG_ERROR(Lib_Rtc, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRtcFormatRFC3339Precise() {
+    LOG_ERROR(Lib_Rtc, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRtcFormatRFC3339PreciseLocalTime() {
+    LOG_ERROR(Lib_Rtc, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRtcGetCurrentAdNetworkTick() {
+    LOG_ERROR(Lib_Rtc, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRtcGetCurrentClock() {
+    LOG_ERROR(Lib_Rtc, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRtcGetCurrentClockLocalTime() {
+    LOG_ERROR(Lib_Rtc, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRtcGetCurrentDebugNetworkTick() {
+    LOG_ERROR(Lib_Rtc, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRtcGetCurrentNetworkTick() {
+    LOG_ERROR(Lib_Rtc, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRtcGetCurrentRawNetworkTick() {
+    LOG_ERROR(Lib_Rtc, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRtcGetCurrentTick(OrbisRtcTick* pTick) {
+    pTick->tick = std::chrono::duration_cast<std::chrono::nanoseconds>(
+                      std::chrono::high_resolution_clock::now().time_since_epoch())
+                      .count();
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRtcGetDayOfWeek() {
+    LOG_ERROR(Lib_Rtc, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRtcGetDaysInMonth() {
+    LOG_ERROR(Lib_Rtc, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRtcGetDosTime() {
+    LOG_ERROR(Lib_Rtc, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRtcGetTick() {
+    LOG_ERROR(Lib_Rtc, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRtcGetTickResolution() {
+    LOG_ERROR(Lib_Rtc, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRtcGetTime_t() {
+    LOG_ERROR(Lib_Rtc, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRtcGetWin32FileTime() {
+    LOG_ERROR(Lib_Rtc, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRtcInit() {
+    LOG_ERROR(Lib_Rtc, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRtcIsLeapYear() {
+    LOG_ERROR(Lib_Rtc, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRtcParseDateTime() {
+    LOG_ERROR(Lib_Rtc, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRtcParseRFC3339() {
+    LOG_ERROR(Lib_Rtc, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRtcSetConf() {
+    LOG_ERROR(Lib_Rtc, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRtcSetCurrentAdNetworkTick() {
+    LOG_ERROR(Lib_Rtc, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRtcSetCurrentDebugNetworkTick() {
+    LOG_ERROR(Lib_Rtc, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRtcSetCurrentNetworkTick() {
+    LOG_ERROR(Lib_Rtc, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRtcSetCurrentTick() {
+    LOG_ERROR(Lib_Rtc, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRtcSetDosTime() {
+    LOG_ERROR(Lib_Rtc, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRtcSetTick() {
+    LOG_ERROR(Lib_Rtc, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRtcSetTime_t() {
+    LOG_ERROR(Lib_Rtc, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRtcSetWin32FileTime() {
+    LOG_ERROR(Lib_Rtc, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRtcTickAddDays() {
+    LOG_ERROR(Lib_Rtc, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRtcTickAddHours() {
+    LOG_ERROR(Lib_Rtc, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRtcTickAddMicroseconds() {
+    LOG_ERROR(Lib_Rtc, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRtcTickAddMinutes() {
+    LOG_ERROR(Lib_Rtc, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRtcTickAddMonths() {
+    LOG_ERROR(Lib_Rtc, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRtcTickAddSeconds() {
+    LOG_ERROR(Lib_Rtc, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRtcTickAddTicks() {
+    LOG_ERROR(Lib_Rtc, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRtcTickAddWeeks() {
+    LOG_ERROR(Lib_Rtc, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceRtcTickAddYears() {
+    LOG_ERROR(Lib_Rtc, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+void RegisterlibSceRtc(Core::Loader::SymbolsResolver* sym) {
+    LIB_FUNCTION("lPEBYdVX0XQ", "libSceRtc", 1, "libSceRtc", 1, 1, sceRtcCheckValid);
+    LIB_FUNCTION("fNaZ4DbzHAE", "libSceRtc", 1, "libSceRtc", 1, 1, sceRtcCompareTick);
+    LIB_FUNCTION("8Yr143yEnRo", "libSceRtc", 1, "libSceRtc", 1, 1, sceRtcConvertLocalTimeToUtc);
+    LIB_FUNCTION("M1TvFst-jrM", "libSceRtc", 1, "libSceRtc", 1, 1, sceRtcConvertUtcToLocalTime);
+    LIB_FUNCTION("8SljQx6pDP8", "libSceRtc", 1, "libSceRtc", 1, 1, sceRtcEnd);
+    LIB_FUNCTION("eiuobaF-hK4", "libSceRtc", 1, "libSceRtc", 1, 1, sceRtcFormatRFC2822);
+    LIB_FUNCTION("AxHBk3eat04", "libSceRtc", 1, "libSceRtc", 1, 1, sceRtcFormatRFC2822LocalTime);
+    LIB_FUNCTION("WJ3rqFwymew", "libSceRtc", 1, "libSceRtc", 1, 1, sceRtcFormatRFC3339);
+    LIB_FUNCTION("DwuHIlLGW8I", "libSceRtc", 1, "libSceRtc", 1, 1, sceRtcFormatRFC3339LocalTime);
+    LIB_FUNCTION("lja0nNPWojg", "libSceRtc", 1, "libSceRtc", 1, 1, sceRtcFormatRFC3339Precise);
+    LIB_FUNCTION("tOZ6fwwHZOA", "libSceRtc", 1, "libSceRtc", 1, 1,
+                 sceRtcFormatRFC3339PreciseLocalTime);
+    LIB_FUNCTION("LN3Zcb72Q0c", "libSceRtc", 1, "libSceRtc", 1, 1, sceRtcGetCurrentAdNetworkTick);
+    LIB_FUNCTION("8lfvnRMqwEM", "libSceRtc", 1, "libSceRtc", 1, 1, sceRtcGetCurrentClock);
+    LIB_FUNCTION("ZPD1YOKI+Kw", "libSceRtc", 1, "libSceRtc", 1, 1, sceRtcGetCurrentClockLocalTime);
+    LIB_FUNCTION("Ot1DE3gif84", "libSceRtc", 1, "libSceRtc", 1, 1,
+                 sceRtcGetCurrentDebugNetworkTick);
+    LIB_FUNCTION("zO9UL3qIINQ", "libSceRtc", 1, "libSceRtc", 1, 1, sceRtcGetCurrentNetworkTick);
+    LIB_FUNCTION("HWxHOdbM-Pg", "libSceRtc", 1, "libSceRtc", 1, 1, sceRtcGetCurrentRawNetworkTick);
+    LIB_FUNCTION("18B2NS1y9UU", "libSceRtc", 1, "libSceRtc", 1, 1, sceRtcGetCurrentTick);
+    LIB_FUNCTION("CyIK-i4XdgQ", "libSceRtc", 1, "libSceRtc", 1, 1, sceRtcGetDayOfWeek);
+    LIB_FUNCTION("3O7Ln8AqJ1o", "libSceRtc", 1, "libSceRtc", 1, 1, sceRtcGetDaysInMonth);
+    LIB_FUNCTION("E7AR4o7Ny7E", "libSceRtc", 1, "libSceRtc", 1, 1, sceRtcGetDosTime);
+    LIB_FUNCTION("8w-H19ip48I", "libSceRtc", 1, "libSceRtc", 1, 1, sceRtcGetTick);
+    LIB_FUNCTION("jMNwqYr4R-k", "libSceRtc", 1, "libSceRtc", 1, 1, sceRtcGetTickResolution);
+    LIB_FUNCTION("BtqmpTRXHgk", "libSceRtc", 1, "libSceRtc", 1, 1, sceRtcGetTime_t);
+    LIB_FUNCTION("jfRO0uTjtzA", "libSceRtc", 1, "libSceRtc", 1, 1, sceRtcGetWin32FileTime);
+    LIB_FUNCTION("LlodCMDbk3o", "libSceRtc", 1, "libSceRtc", 1, 1, sceRtcInit);
+    LIB_FUNCTION("Ug8pCwQvh0c", "libSceRtc", 1, "libSceRtc", 1, 1, sceRtcIsLeapYear);
+    LIB_FUNCTION("NxEI1KByvCI", "libSceRtc", 1, "libSceRtc", 1, 1, sceRtcParseDateTime);
+    LIB_FUNCTION("99bMGglFW3I", "libSceRtc", 1, "libSceRtc", 1, 1, sceRtcParseRFC3339);
+    LIB_FUNCTION("fFLgmNUpChg", "libSceRtc", 1, "libSceRtc", 1, 1, sceRtcSetConf);
+    LIB_FUNCTION("sV2tK+yOhBU", "libSceRtc", 1, "libSceRtc", 1, 1, sceRtcSetCurrentAdNetworkTick);
+    LIB_FUNCTION("VLDUPKmw5L8", "libSceRtc", 1, "libSceRtc", 1, 1,
+                 sceRtcSetCurrentDebugNetworkTick);
+    LIB_FUNCTION("qhDBtIo+auw", "libSceRtc", 1, "libSceRtc", 1, 1, sceRtcSetCurrentNetworkTick);
+    LIB_FUNCTION("d4fHLCGmY80", "libSceRtc", 1, "libSceRtc", 1, 1, sceRtcSetCurrentTick);
+    LIB_FUNCTION("aYPCd1cChyg", "libSceRtc", 1, "libSceRtc", 1, 1, sceRtcSetDosTime);
+    LIB_FUNCTION("ueega6v3GUw", "libSceRtc", 1, "libSceRtc", 1, 1, sceRtcSetTick);
+    LIB_FUNCTION("bDEVVP4bTjQ", "libSceRtc", 1, "libSceRtc", 1, 1, sceRtcSetTime_t);
+    LIB_FUNCTION("n5JiAJXsbcs", "libSceRtc", 1, "libSceRtc", 1, 1, sceRtcSetWin32FileTime);
+    LIB_FUNCTION("NR1J0N7L2xY", "libSceRtc", 1, "libSceRtc", 1, 1, sceRtcTickAddDays);
+    LIB_FUNCTION("MDc5cd8HfCA", "libSceRtc", 1, "libSceRtc", 1, 1, sceRtcTickAddHours);
+    LIB_FUNCTION("XPIiw58C+GM", "libSceRtc", 1, "libSceRtc", 1, 1, sceRtcTickAddMicroseconds);
+    LIB_FUNCTION("mn-tf4QiFzk", "libSceRtc", 1, "libSceRtc", 1, 1, sceRtcTickAddMinutes);
+    LIB_FUNCTION("CL6y9q-XbuQ", "libSceRtc", 1, "libSceRtc", 1, 1, sceRtcTickAddMonths);
+    LIB_FUNCTION("07O525HgICs", "libSceRtc", 1, "libSceRtc", 1, 1, sceRtcTickAddSeconds);
+    LIB_FUNCTION("AqVMssr52Rc", "libSceRtc", 1, "libSceRtc", 1, 1, sceRtcTickAddTicks);
+    LIB_FUNCTION("gI4t194c2W8", "libSceRtc", 1, "libSceRtc", 1, 1, sceRtcTickAddWeeks);
+    LIB_FUNCTION("-5y2uJ62qS8", "libSceRtc", 1, "libSceRtc", 1, 1, sceRtcTickAddYears);
+};
+
+} // namespace Libraries::Rtc

src/core/libraries/rtc/rtc.h

@@ -0,0 +1,67 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "common/types.h"
+
+namespace Core::Loader {
+class SymbolsResolver;
+}
+
+namespace Libraries::Rtc {
+
+struct OrbisRtcTick {
+    u64 tick;
+};
+
+int PS4_SYSV_ABI sceRtcCheckValid();
+int PS4_SYSV_ABI sceRtcCompareTick();
+int PS4_SYSV_ABI sceRtcConvertLocalTimeToUtc();
+int PS4_SYSV_ABI sceRtcConvertUtcToLocalTime();
+int PS4_SYSV_ABI sceRtcEnd();
+int PS4_SYSV_ABI sceRtcFormatRFC2822();
+int PS4_SYSV_ABI sceRtcFormatRFC2822LocalTime();
+int PS4_SYSV_ABI sceRtcFormatRFC3339();
+int PS4_SYSV_ABI sceRtcFormatRFC3339LocalTime();
+int PS4_SYSV_ABI sceRtcFormatRFC3339Precise();
+int PS4_SYSV_ABI sceRtcFormatRFC3339PreciseLocalTime();
+int PS4_SYSV_ABI sceRtcGetCurrentAdNetworkTick();
+int PS4_SYSV_ABI sceRtcGetCurrentClock();
+int PS4_SYSV_ABI sceRtcGetCurrentClockLocalTime();
+int PS4_SYSV_ABI sceRtcGetCurrentDebugNetworkTick();
+int PS4_SYSV_ABI sceRtcGetCurrentNetworkTick();
+int PS4_SYSV_ABI sceRtcGetCurrentRawNetworkTick();
+int PS4_SYSV_ABI sceRtcGetCurrentTick(OrbisRtcTick* pTick);
+int PS4_SYSV_ABI sceRtcGetDayOfWeek();
+int PS4_SYSV_ABI sceRtcGetDaysInMonth();
+int PS4_SYSV_ABI sceRtcGetDosTime();
+int PS4_SYSV_ABI sceRtcGetTick();
+int PS4_SYSV_ABI sceRtcGetTickResolution();
+int PS4_SYSV_ABI sceRtcGetTime_t();
+int PS4_SYSV_ABI sceRtcGetWin32FileTime();
+int PS4_SYSV_ABI sceRtcInit();
+int PS4_SYSV_ABI sceRtcIsLeapYear();
+int PS4_SYSV_ABI sceRtcParseDateTime();
+int PS4_SYSV_ABI sceRtcParseRFC3339();
+int PS4_SYSV_ABI sceRtcSetConf();
+int PS4_SYSV_ABI sceRtcSetCurrentAdNetworkTick();
+int PS4_SYSV_ABI sceRtcSetCurrentDebugNetworkTick();
+int PS4_SYSV_ABI sceRtcSetCurrentNetworkTick();
+int PS4_SYSV_ABI sceRtcSetCurrentTick();
+int PS4_SYSV_ABI sceRtcSetDosTime();
+int PS4_SYSV_ABI sceRtcSetTick();
+int PS4_SYSV_ABI sceRtcSetTime_t();
+int PS4_SYSV_ABI sceRtcSetWin32FileTime();
+int PS4_SYSV_ABI sceRtcTickAddDays();
+int PS4_SYSV_ABI sceRtcTickAddHours();
+int PS4_SYSV_ABI sceRtcTickAddMicroseconds();
+int PS4_SYSV_ABI sceRtcTickAddMinutes();
+int PS4_SYSV_ABI sceRtcTickAddMonths();
+int PS4_SYSV_ABI sceRtcTickAddSeconds();
+int PS4_SYSV_ABI sceRtcTickAddTicks();
+int PS4_SYSV_ABI sceRtcTickAddWeeks();
+int PS4_SYSV_ABI sceRtcTickAddYears();
+
+void RegisterlibSceRtc(Core::Loader::SymbolsResolver* sym);
+} // namespace Libraries::Rtc

src/core/libraries/save_data/savedata.cpp

@@ -340,7 +340,8 @@ s32 saveDataMount(u32 user_id, std::string dir_name, u32 mount_mode,
                             std::to_string(user_id) / "savedata" / id / dir_name;
     switch (mount_mode) {
     case ORBIS_SAVE_DATA_MOUNT_MODE_RDONLY:
-    case ORBIS_SAVE_DATA_MOUNT_MODE_RDWR: {
+    case ORBIS_SAVE_DATA_MOUNT_MODE_RDWR:
+    case ORBIS_SAVE_DATA_MOUNT_MODE_RDONLY | ORBIS_SAVE_DATA_MOUNT_MODE_DESTRUCT_OFF: {
         if (!std::filesystem::exists(mount_dir)) {
             return ORBIS_SAVE_DATA_ERROR_NOT_FOUND;
         }
@@ -352,6 +353,8 @@ s32 saveDataMount(u32 user_id, std::string dir_name, u32 mount_mode,
     } break;
     case ORBIS_SAVE_DATA_MOUNT_MODE_CREATE | ORBIS_SAVE_DATA_MOUNT_MODE_RDWR:
     case ORBIS_SAVE_DATA_MOUNT_MODE_CREATE | ORBIS_SAVE_DATA_MOUNT_MODE_RDWR |
+        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: {
         if (std::filesystem::exists(mount_dir)) {
             return ORBIS_SAVE_DATA_ERROR_EXISTS;
@@ -364,6 +367,7 @@ s32 saveDataMount(u32 user_id, std::string dir_name, u32 mount_mode,
         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 |
         ORBIS_SAVE_DATA_MOUNT_MODE_COPY_ICON: {
         if (!std::filesystem::exists(mount_dir)) {
@@ -728,4 +732,4 @@ void RegisterlibSceSaveData(Core::Loader::SymbolsResolver* sym) {
     LIB_FUNCTION("AuTE0gFxZCI", "libSceSaveData", 1, "libSceSaveData", 1, 1, Func_02E4C4D201716422);
 };
 
-} // namespace Libraries::SaveData
+} // namespace Libraries::SaveData

src/core/memory.cpp

@@ -92,10 +92,7 @@ int MemoryManager::MapMemory(void** out_addr, VAddr virtual_addr, size_t size, M
             it++;
         }
         ASSERT(it != vma_map.end());
-        if (alignment > 0) {
-            ASSERT_MSG(it->second.base % alignment == 0, "Free region base is not aligned");
-        }
-        mapped_addr = it->second.base;
+        mapped_addr = alignment > 0 ? Common::AlignUp(it->second.base, alignment) : it->second.base;
     }
 
     // Perform the mapping.

src/core/memory.h

@@ -115,6 +115,10 @@ public:
 
     int DirectMemoryQuery(PAddr addr, bool find_next, Libraries::Kernel::OrbisQueryInfo* out_info);
 
+    VAddr Reserve(size_t size, u64 alignment) {
+        return reinterpret_cast<VAddr>(impl.Reserve(size, alignment));
+    }
+
     std::pair<vk::Buffer, size_t> GetVulkanBuffer(VAddr addr);
 
 private:

src/video_core/texture_cache/texture_cache.h

@@ -7,12 +7,12 @@
 #include <boost/icl/interval_map.hpp>
 #include <tsl/robin_map.h>
 
+#include "common/slot_vector.h"
 #include "video_core/amdgpu/resource.h"
 #include "video_core/renderer_vulkan/vk_stream_buffer.h"
 #include "video_core/texture_cache/image.h"
 #include "video_core/texture_cache/image_view.h"
 #include "video_core/texture_cache/sampler.h"
-#include "video_core/texture_cache/slot_vector.h"
 #include "video_core/texture_cache/tile_manager.h"
 
 namespace Core::Libraries::VideoOut {

src/video_core/texture_cache/types.h

@@ -3,8 +3,8 @@
 
 #pragma once
 
+#include "common/slot_vector.h"
 #include "common/types.h"
-#include "video_core/texture_cache/slot_vector.h"
 
 namespace VideoCore {