From 86bc2d427fab48fb53b601f0d7f791aa0cb6b48d Mon Sep 17 00:00:00 2001 From: georgemoralis Date: Fri, 10 Nov 2023 17:31:56 +0200 Subject: [PATCH 01/14] moved thread_management to proper package --- CMakeLists.txt | 4 ++-- .../hle/{kernel => libraries/libkernel}/thread_management.cpp | 2 +- .../hle/{kernel => libraries/libkernel}/thread_management.h | 0 src/core/linker.cpp | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) rename src/core/hle/{kernel => libraries/libkernel}/thread_management.cpp (98%) rename src/core/hle/{kernel => libraries/libkernel}/thread_management.h (100%) diff --git a/CMakeLists.txt b/CMakeLists.txt index c1483383..d4d605f4 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -119,8 +119,8 @@ add_executable(shadps4 src/core/hle/libraries/libkernel/libkernel.h src/core/hle/libraries/libscegnmdriver/libscegnmdriver.cpp src/core/hle/libraries/libscegnmdriver/libscegnmdriver.h - src/core/hle/kernel/thread_management.cpp - src/core/hle/kernel/thread_management.h + src/core/hle/libraries/libkernel/thread_management.cpp + src/core/hle/libraries/libkernel/thread_management.h src/core/hle/kernel/memory_management.cpp src/core/hle/kernel/memory_management.h src/core/hle/error_codes.h diff --git a/src/core/hle/kernel/thread_management.cpp b/src/core/hle/libraries/libkernel/thread_management.cpp similarity index 98% rename from src/core/hle/kernel/thread_management.cpp rename to src/core/hle/libraries/libkernel/thread_management.cpp index b7945850..32afa443 100644 --- a/src/core/hle/kernel/thread_management.cpp +++ b/src/core/hle/libraries/libkernel/thread_management.cpp @@ -1,5 +1,5 @@ #include "common/debug.h" -#include "core/hle/kernel/thread_management.h" +#include "core/hle/libraries/libkernel/thread_management.h" #include "core/hle/error_codes.h" namespace Core::Kernel { diff --git a/src/core/hle/kernel/thread_management.h b/src/core/hle/libraries/libkernel/thread_management.h similarity index 100% rename from src/core/hle/kernel/thread_management.h rename to src/core/hle/libraries/libkernel/thread_management.h diff --git a/src/core/linker.cpp b/src/core/linker.cpp index 2d773247..cd1bbc9d 100644 --- a/src/core/linker.cpp +++ b/src/core/linker.cpp @@ -4,7 +4,7 @@ #include "common/string_util.h" #include "core/aerolib/aerolib.h" #include "core/aerolib/stubs.h" -#include "core/hle/kernel/thread_management.h" +#include "core/hle/libraries/libkernel/thread_management.h" #include "core/linker.h" #include "core/virtual_memory.h" From 91885e8a413a6ce2689add5cc48c6e1862b7c9b3 Mon Sep 17 00:00:00 2001 From: georgemoralis Date: Fri, 10 Nov 2023 19:52:41 +0200 Subject: [PATCH 02/14] added sceMutexInit functions --- .../hle/libraries/libkernel/libkernel.cpp | 2 + .../libraries/libkernel/thread_management.cpp | 123 ++++++++++++++++-- .../libraries/libkernel/thread_management.h | 62 +++++++-- src/main.cpp | 24 ++-- 4 files changed, 181 insertions(+), 30 deletions(-) diff --git a/src/core/hle/libraries/libkernel/libkernel.cpp b/src/core/hle/libraries/libkernel/libkernel.cpp index 65b96dcd..7ab71291 100644 --- a/src/core/hle/libraries/libkernel/libkernel.cpp +++ b/src/core/hle/libraries/libkernel/libkernel.cpp @@ -14,6 +14,7 @@ #ifdef _WIN64 #include #endif +#include "thread_management.h" namespace Core::Libraries::LibKernel { @@ -50,6 +51,7 @@ void LibKernel_Register(Loader::SymbolsResolver* sym) { Core::Libraries::LibKernel::fileSystemSymbolsRegister(sym); Core::Libraries::LibKernel::timeSymbolsRegister(sym); + Core::Libraries::LibKernel::pthreadSymbolsRegister(sym); } } // namespace Core::Libraries::LibKernel diff --git a/src/core/hle/libraries/libkernel/thread_management.cpp b/src/core/hle/libraries/libkernel/thread_management.cpp index 32afa443..5a6297f2 100644 --- a/src/core/hle/libraries/libkernel/thread_management.cpp +++ b/src/core/hle/libraries/libkernel/thread_management.cpp @@ -1,19 +1,32 @@ -#include "common/debug.h" #include "core/hle/libraries/libkernel/thread_management.h" + +#include + +#include "common/debug.h" +#include "common/log.h" #include "core/hle/error_codes.h" -namespace Core::Kernel { +namespace Core::Libraries::LibKernel { thread_local PthreadInternal g_pthread_self{}; PThreadCxt* g_pthread_cxt = nullptr; +constexpr bool log_pthread_file = true; // disable it to disable logging + +void init_pthreads() { + g_pthread_cxt = new PThreadCxt{}; + ScePthreadMutexattr default_mutexattr = nullptr; + scePthreadMutexattrInit(&default_mutexattr); + g_pthread_cxt->setDefaultMutexattr(default_mutexattr); +} + void Pthread_Init_Self_MainThread() { scePthreadAttrInit(&g_pthread_self.attr); g_pthread_self.pth = pthread_self(); g_pthread_self.name = "Main_Thread"; } -int scePthreadAttrInit(ScePthreadAttr* attr) { +int PS4_SYSV_ABI scePthreadAttrInit(ScePthreadAttr* attr) { *attr = new PthreadAttrInternal{}; int result = pthread_attr_init(&(*attr)->pth_attr); @@ -36,7 +49,7 @@ int scePthreadAttrInit(ScePthreadAttr* attr) { } } -int scePthreadAttrSetdetachstate(ScePthreadAttr* attr, int detachstate) { +int PS4_SYSV_ABI scePthreadAttrSetdetachstate(ScePthreadAttr* attr, int detachstate) { if (attr == nullptr || *attr == nullptr) { return SCE_KERNEL_ERROR_EINVAL; } @@ -58,7 +71,7 @@ int scePthreadAttrSetdetachstate(ScePthreadAttr* attr, int detachstate) { return SCE_KERNEL_ERROR_EINVAL; } -int scePthreadAttrSetinheritsched(ScePthreadAttr* attr, int inheritSched) { +int PS4_SYSV_ABI scePthreadAttrSetinheritsched(ScePthreadAttr* attr, int inheritSched) { if (attr == nullptr || *attr == nullptr) { return SCE_KERNEL_ERROR_EINVAL; } @@ -78,7 +91,7 @@ int scePthreadAttrSetinheritsched(ScePthreadAttr* attr, int inheritSched) { return SCE_KERNEL_ERROR_EINVAL; } -int scePthreadAttrSetschedparam(ScePthreadAttr* attr, const SceKernelSchedParam* param) { +int PS4_SYSV_ABI scePthreadAttrSetschedparam(ScePthreadAttr* attr, const SceKernelSchedParam* param) { if (param == nullptr || attr == nullptr || *attr == nullptr) { return SCE_KERNEL_ERROR_EINVAL; } @@ -100,7 +113,7 @@ int scePthreadAttrSetschedparam(ScePthreadAttr* attr, const SceKernelSchedParam* return SCE_KERNEL_ERROR_EINVAL; } -int scePthreadAttrSetschedpolicy(ScePthreadAttr* attr, int policy) { +int PS4_SYSV_ABI scePthreadAttrSetschedpolicy(ScePthreadAttr* attr, int policy) { if (attr == nullptr || *attr == nullptr) { return SCE_KERNEL_ERROR_EINVAL; } @@ -119,4 +132,98 @@ int scePthreadAttrSetschedpolicy(ScePthreadAttr* attr, int policy) { return SCE_KERNEL_ERROR_EINVAL; } -} // namespace Core::Kernel +/**** + * Mutex calls + */ +int PS4_SYSV_ABI scePthreadMutexInit(ScePthreadMutex* mutex, const ScePthreadMutexattr* attr, const char* name) { + PRINT_FUNCTION_NAME(); + if (mutex == nullptr) { + return SCE_KERNEL_ERROR_EINVAL; + } + if (attr == nullptr) { + attr = g_pthread_cxt->getDefaultMutexattr(); + } + + *mutex = new PthreadMutexInternal{}; + if (name != nullptr) { + (*mutex)->name = name; + } + + int result = pthread_mutex_init(&(*mutex)->pth_mutex, &(*attr)->pth_mutex_attr); + + if (name != nullptr) { + LOG_INFO_IF(log_pthread_file, "mutex_init name={},result={}\n"); + } + + switch (result) { + case 0: return SCE_OK; + case EAGAIN: return SCE_KERNEL_ERROR_EAGAIN; + case EINVAL: return SCE_KERNEL_ERROR_EINVAL; + case ENOMEM: return SCE_KERNEL_ERROR_ENOMEM; + default: return SCE_KERNEL_ERROR_EINVAL; + } +} +int PS4_SYSV_ABI scePthreadMutexattrInit(ScePthreadMutexattr* attr) { + *attr = new PthreadMutexattrInternal{}; + + int result = pthread_mutexattr_init(&(*attr)->pth_mutex_attr); + + result = (result == 0 ? scePthreadMutexattrSettype(attr, 1) : result); + result = (result == 0 ? scePthreadMutexattrSetprotocol(attr, 0) : result); + + switch (result) { + case 0: return SCE_OK; + case ENOMEM: return SCE_KERNEL_ERROR_ENOMEM; + default: return SCE_KERNEL_ERROR_EINVAL; + } +} + +int PS4_SYSV_ABI scePthreadMutexattrSettype(ScePthreadMutexattr* attr, int type) { + int ptype = PTHREAD_MUTEX_DEFAULT; + switch (type) { + case 1: ptype = PTHREAD_MUTEX_ERRORCHECK; break; + case 2: ptype = PTHREAD_MUTEX_RECURSIVE; break; + case 3: + case 4: ptype = PTHREAD_MUTEX_NORMAL; break; + default: LOG_TRACE_IF(log_pthread_file, "scePthreadMutexattrSettype invalid type: {}\n", type); std::exit(0); + } + + int result = pthread_mutexattr_settype(&(*attr)->pth_mutex_attr, ptype); + + return result == 0 ? SCE_OK : SCE_KERNEL_ERROR_EINVAL; +} + +int PS4_SYSV_ABI scePthreadMutexattrSetprotocol(ScePthreadMutexattr* attr, int protocol) { + int pprotocol = PTHREAD_PRIO_NONE; + switch (protocol) { + case 0: pprotocol = PTHREAD_PRIO_NONE; break; + case 1: pprotocol = PTHREAD_PRIO_INHERIT; break; + case 2: pprotocol = PTHREAD_PRIO_PROTECT; break; + default: LOG_TRACE_IF(log_pthread_file, "scePthreadMutexattrSetprotocol invalid protocol: {}\n", protocol); std::exit(0); + } + + int result = 0; // pthread_mutexattr_setprotocol(&(*attr)->p, pprotocol); //it appears that pprotocol has issues in winpthreads + (*attr)->pprotocol = pprotocol; + + return result == 0 ? SCE_OK : SCE_KERNEL_ERROR_EINVAL; +} + +int PS4_SYSV_ABI posix_pthread_mutex_init(ScePthreadMutex* mutex, const ScePthreadMutexattr* attr) { + LOG_INFO_IF(log_pthread_file, "posix pthread_mutex_init redirect to scePthreadMutexInit\n"); + int result = scePthreadMutexInit(mutex, attr, nullptr); + if (result < 0) { + BREAKPOINT(); // posix calls different only for their return values + } + return result; +} + +void pthreadSymbolsRegister(Loader::SymbolsResolver* sym) { + LIB_FUNCTION("cmo1RIYva9o", "libkernel", 1, "libkernel", 1, 1, scePthreadMutexInit); + LIB_FUNCTION("F8bUHwAG284", "libkernel", 1, "libkernel", 1, 1, scePthreadMutexattrInit); + LIB_FUNCTION("iMp8QpE+XO4", "libkernel", 1, "libkernel", 1, 1, scePthreadMutexattrSettype); + LIB_FUNCTION("1FGvU0i9saQ", "libkernel", 1, "libkernel", 1, 1, scePthreadMutexattrSetprotocol); + // posix calls + LIB_FUNCTION("ttHNfU+qDBU", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_mutex_init); +} + +} // namespace Core::Libraries::LibKernel diff --git a/src/core/hle/libraries/libkernel/thread_management.h b/src/core/hle/libraries/libkernel/thread_management.h index 4dd50eb9..68d4fe5b 100644 --- a/src/core/hle/libraries/libkernel/thread_management.h +++ b/src/core/hle/libraries/libkernel/thread_management.h @@ -3,15 +3,25 @@ #include #include -#include "common/types.h" + #include -namespace Core::Kernel { +#include "common/types.h" + +namespace Core::Loader { +class SymbolsResolver; +} + +namespace Core::Libraries::LibKernel { struct PthreadAttrInternal; +struct PthreadMutexInternal; +struct PthreadMutexattrInternal; -using SceKernelSchedParam = ::sched_param; +using SceKernelSchedParam = ::sched_param; using ScePthreadAttr = PthreadAttrInternal*; +using ScePthreadMutex = PthreadMutexInternal*; +using ScePthreadMutexattr = PthreadMutexattrInternal*; struct PthreadInternal { u08 reserved[4096]; @@ -29,14 +39,46 @@ struct PthreadAttrInternal { pthread_attr_t pth_attr; }; -class PThreadCxt {}; +struct PthreadMutexInternal { + u08 reserved[256]; + std::string name; + pthread_mutex_t pth_mutex; +}; +struct PthreadMutexattrInternal { + u08 reserved[64]; + pthread_mutexattr_t pth_mutex_attr; + int pprotocol; +}; + +class PThreadCxt { + public: + ScePthreadMutexattr* getDefaultMutexattr() { return &m_default_mutexattr; } + void setDefaultMutexattr(ScePthreadMutexattr attr) { m_default_mutexattr = attr; } + + private: + ScePthreadMutexattr m_default_mutexattr = nullptr; +}; +void init_pthreads(); void Pthread_Init_Self_MainThread(); -int scePthreadAttrInit(ScePthreadAttr* attr); -int scePthreadAttrSetdetachstate(ScePthreadAttr* attr, int detachstate); -int scePthreadAttrSetinheritsched(ScePthreadAttr* attr, int inheritSched); -int scePthreadAttrSetschedparam(ScePthreadAttr* attr, const SceKernelSchedParam* param); -int scePthreadAttrSetschedpolicy(ScePthreadAttr* attr, int policy); +int PS4_SYSV_ABI scePthreadAttrInit(ScePthreadAttr* attr); +int PS4_SYSV_ABI scePthreadAttrSetdetachstate(ScePthreadAttr* attr, int detachstate); +int PS4_SYSV_ABI scePthreadAttrSetinheritsched(ScePthreadAttr* attr, int inheritSched); +int PS4_SYSV_ABI scePthreadAttrSetschedparam(ScePthreadAttr* attr, const SceKernelSchedParam* param); +int PS4_SYSV_ABI scePthreadAttrSetschedpolicy(ScePthreadAttr* attr, int policy); -} // namespace Core::Kernel +/*** + * Mutex calls + */ +int PS4_SYSV_ABI scePthreadMutexInit(ScePthreadMutex* mutex, const ScePthreadMutexattr* attr, const char* name); +int PS4_SYSV_ABI scePthreadMutexattrInit(ScePthreadMutexattr* attr); +int PS4_SYSV_ABI scePthreadMutexattrSettype(ScePthreadMutexattr* attr, int type); +int PS4_SYSV_ABI scePthreadMutexattrSetprotocol(ScePthreadMutexattr* attr, int protocol); +/**** + * Posix calls + */ +int PS4_SYSV_ABI posix_pthread_mutex_init(ScePthreadMutex* mutex, const ScePthreadMutexattr* attr); + +void pthreadSymbolsRegister(Loader::SymbolsResolver* sym); +} // namespace Core::Libraries::LibKernel diff --git a/src/main.cpp b/src/main.cpp index 4c727527..d9d56865 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -1,19 +1,22 @@ -#include -#include -#include -#include #include #include +#include + +#include +#include +#include + +#include "Util/config.h" #include "common/discord.h" -#include "common/types.h" #include "common/log.h" #include "common/singleton.h" +#include "common/types.h" #include "core/PS4/HLE/Graphics/video_out.h" -#include "Util/config.h" -#include "emulator.h" #include "core/hle/libraries/libs.h" #include "core/linker.h" #include "emuTimer.h" +#include "emulator.h" +#include int main(int argc, char* argv[]) { if (argc == 1) { @@ -22,6 +25,7 @@ int main(int argc, char* argv[]) { } Config::load("config.toml"); Common::Log::Init(true); + Core::Libraries::LibKernel::init_pthreads(); auto width = Config::getScreenWidth(); auto height = Config::getScreenHeight(); Emu::emuInit(width, height); @@ -34,11 +38,7 @@ int main(int argc, char* argv[]) { auto linker = Common::Singleton::Instance(); Core::Libraries::InitHLELibs(&linker->getHLESymbols()); linker->LoadModule(path); - std::jthread mainthread( - [linker](std::stop_token stop_token, void*) { - linker->Execute(); - }, - nullptr); + std::jthread mainthread([linker](std::stop_token stop_token, void*) { linker->Execute(); }, nullptr); Discord::RPC discordRPC; discordRPC.init(); discordRPC.update(Discord::RPCStatus::Idling, ""); From a10af461536a68efd5981cc1cdcdc33838b27fa8 Mon Sep 17 00:00:00 2001 From: georgemoralis Date: Fri, 10 Nov 2023 20:51:02 +0200 Subject: [PATCH 03/14] some refactoring on thread class --- .../libraries/libkernel/thread_management.cpp | 33 +++++++------------ src/core/linker.cpp | 2 +- 2 files changed, 13 insertions(+), 22 deletions(-) diff --git a/src/core/hle/libraries/libkernel/thread_management.cpp b/src/core/hle/libraries/libkernel/thread_management.cpp index 5a6297f2..eea73442 100644 --- a/src/core/hle/libraries/libkernel/thread_management.cpp +++ b/src/core/hle/libraries/libkernel/thread_management.cpp @@ -58,17 +58,14 @@ int PS4_SYSV_ABI scePthreadAttrSetdetachstate(ScePthreadAttr* attr, int detachst switch (detachstate) { case 0: pstate = PTHREAD_CREATE_JOINABLE; break; case 1: pstate = PTHREAD_CREATE_DETACHED; break; - default: BREAKPOINT(); // unknown state + default: LOG_TRACE_IF(log_pthread_file, "scePthreadAttrSetdetachstate invalid detachstate: {}\n", detachstate); std::exit(0); } int result = pthread_attr_setdetachstate(&(*attr)->pth_attr, pstate); (*attr)->detached = (pstate == PTHREAD_CREATE_DETACHED); - if (result == 0) { - return SCE_OK; - } - return SCE_KERNEL_ERROR_EINVAL; + return result == 0 ? SCE_OK : SCE_KERNEL_ERROR_EINVAL; } int PS4_SYSV_ABI scePthreadAttrSetinheritsched(ScePthreadAttr* attr, int inheritSched) { @@ -80,15 +77,12 @@ int PS4_SYSV_ABI scePthreadAttrSetinheritsched(ScePthreadAttr* attr, int inherit switch (inheritSched) { case 0: pinherit_sched = PTHREAD_EXPLICIT_SCHED; break; case 4: pinherit_sched = PTHREAD_INHERIT_SCHED; break; - default: BREAKPOINT(); // unknown inheritSched + default: LOG_TRACE_IF(log_pthread_file, "scePthreadAttrSetinheritsched invalid inheritSched: {}\n", inheritSched); std::exit(0); } int result = pthread_attr_setinheritsched(&(*attr)->pth_attr, pinherit_sched); - if (result == 0) { - return SCE_OK; - } - return SCE_KERNEL_ERROR_EINVAL; + return result == 0 ? SCE_OK : SCE_KERNEL_ERROR_EINVAL; } int PS4_SYSV_ABI scePthreadAttrSetschedparam(ScePthreadAttr* attr, const SceKernelSchedParam* param) { @@ -107,10 +101,7 @@ int PS4_SYSV_ABI scePthreadAttrSetschedparam(ScePthreadAttr* attr, const SceKern int result = pthread_attr_setschedparam(&(*attr)->pth_attr, &pparam); - if (result == 0) { - return SCE_OK; - } - return SCE_KERNEL_ERROR_EINVAL; + return result == 0 ? SCE_OK : SCE_KERNEL_ERROR_EINVAL; } int PS4_SYSV_ABI scePthreadAttrSetschedpolicy(ScePthreadAttr* attr, int policy) { @@ -118,18 +109,13 @@ int PS4_SYSV_ABI scePthreadAttrSetschedpolicy(ScePthreadAttr* attr, int policy) return SCE_KERNEL_ERROR_EINVAL; } - if (policy != SCHED_OTHER) { - BREAKPOINT(); // invest if policy is other and if winpthreadlibrary support it - } + int ppolicy = SCHED_OTHER; // winpthreads only supports SCHED_OTHER (*attr)->policy = policy; int result = pthread_attr_setschedpolicy(&(*attr)->pth_attr, policy); - if (result == 0) { - return SCE_OK; - } - return SCE_KERNEL_ERROR_EINVAL; + return result == 0 ? SCE_OK : SCE_KERNEL_ERROR_EINVAL; } /**** @@ -222,6 +208,11 @@ void pthreadSymbolsRegister(Loader::SymbolsResolver* sym) { LIB_FUNCTION("F8bUHwAG284", "libkernel", 1, "libkernel", 1, 1, scePthreadMutexattrInit); LIB_FUNCTION("iMp8QpE+XO4", "libkernel", 1, "libkernel", 1, 1, scePthreadMutexattrSettype); LIB_FUNCTION("1FGvU0i9saQ", "libkernel", 1, "libkernel", 1, 1, scePthreadMutexattrSetprotocol); + LIB_FUNCTION("4+h9EzwKF4I", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrSetschedpolicy); + LIB_FUNCTION("-Wreprtu0Qs", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrSetdetachstate); + LIB_FUNCTION("eXbUSpEaTsA", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrSetinheritsched); + LIB_FUNCTION("DzES9hQF4f4", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrSetschedparam); + LIB_FUNCTION("nsYoNRywwNg", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrInit); // posix calls LIB_FUNCTION("ttHNfU+qDBU", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_mutex_init); } diff --git a/src/core/linker.cpp b/src/core/linker.cpp index cd1bbc9d..f9d619ff 100644 --- a/src/core/linker.cpp +++ b/src/core/linker.cpp @@ -654,7 +654,7 @@ static void run_main_entry(u64 addr, EntryParams* params, exit_func_t exit_func) } void Linker::Execute() { - Core::Kernel::Pthread_Init_Self_MainThread(); + Core::Libraries::LibKernel::Pthread_Init_Self_MainThread(); EntryParams p{}; p.argc = 1; p.argv[0] = "eboot.bin"; //hmm should be ok? From 11edfecb756c578c69ae11820da80acd3bf8c3cb Mon Sep 17 00:00:00 2001 From: georgemoralis Date: Fri, 10 Nov 2023 21:08:32 +0200 Subject: [PATCH 04/14] some dummy mutexlock-unlock --- .../libraries/libkernel/thread_management.cpp | 25 ++++++++++++++++++- .../libraries/libkernel/thread_management.h | 4 +++ 2 files changed, 28 insertions(+), 1 deletion(-) diff --git a/src/core/hle/libraries/libkernel/thread_management.cpp b/src/core/hle/libraries/libkernel/thread_management.cpp index eea73442..35b6b990 100644 --- a/src/core/hle/libraries/libkernel/thread_management.cpp +++ b/src/core/hle/libraries/libkernel/thread_management.cpp @@ -193,6 +193,8 @@ int PS4_SYSV_ABI scePthreadMutexattrSetprotocol(ScePthreadMutexattr* attr, int p return result == 0 ? SCE_OK : SCE_KERNEL_ERROR_EINVAL; } +int PS4_SYSV_ABI scePthreadMutexLock(ScePthreadMutex* mutex) {} +int PS4_SYSV_ABI scePthreadMutexUnlock(ScePthreadMutex* mutex) {} int PS4_SYSV_ABI posix_pthread_mutex_init(ScePthreadMutex* mutex, const ScePthreadMutexattr* attr) { LOG_INFO_IF(log_pthread_file, "posix pthread_mutex_init redirect to scePthreadMutexInit\n"); @@ -203,6 +205,24 @@ int PS4_SYSV_ABI posix_pthread_mutex_init(ScePthreadMutex* mutex, const ScePthre return result; } +int PS4_SYSV_ABI posix_pthread_mutex_lock(ScePthreadMutex* mutex) { + LOG_INFO_IF(log_pthread_file, "posix pthread_mutex_lock redirect to scePthreadMutexLock\n"); + int result = scePthreadMutexLock(mutex); + if (result < 0) { + BREAKPOINT(); // posix calls different only for their return values + } + return result; +} + +int PS4_SYSV_ABI posix_pthread_mutex_unlock(ScePthreadMutex* mutex) { + LOG_INFO_IF(log_pthread_file, "posix pthread_mutex_unlock redirect to scePthreadMutexUnlock\n"); + int result = scePthreadMutexUnlock(mutex); + if (result < 0) { + BREAKPOINT(); // posix calls different only for their return values + } + return result; +} + void pthreadSymbolsRegister(Loader::SymbolsResolver* sym) { LIB_FUNCTION("cmo1RIYva9o", "libkernel", 1, "libkernel", 1, 1, scePthreadMutexInit); LIB_FUNCTION("F8bUHwAG284", "libkernel", 1, "libkernel", 1, 1, scePthreadMutexattrInit); @@ -213,8 +233,11 @@ void pthreadSymbolsRegister(Loader::SymbolsResolver* sym) { LIB_FUNCTION("eXbUSpEaTsA", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrSetinheritsched); LIB_FUNCTION("DzES9hQF4f4", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrSetschedparam); LIB_FUNCTION("nsYoNRywwNg", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrInit); + LIB_FUNCTION("9UK1vLZQft4", "libkernel", 1, "libkernel", 1, 1, scePthreadMutexLock); + LIB_FUNCTION("tn3VlD0hG60", "libkernel", 1, "libkernel", 1, 1, scePthreadMutexUnlock); // posix calls - 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); } } // namespace Core::Libraries::LibKernel diff --git a/src/core/hle/libraries/libkernel/thread_management.h b/src/core/hle/libraries/libkernel/thread_management.h index 68d4fe5b..be79a4ce 100644 --- a/src/core/hle/libraries/libkernel/thread_management.h +++ b/src/core/hle/libraries/libkernel/thread_management.h @@ -75,10 +75,14 @@ int PS4_SYSV_ABI scePthreadMutexInit(ScePthreadMutex* mutex, const ScePthreadMut int PS4_SYSV_ABI scePthreadMutexattrInit(ScePthreadMutexattr* attr); int PS4_SYSV_ABI scePthreadMutexattrSettype(ScePthreadMutexattr* attr, int type); int PS4_SYSV_ABI scePthreadMutexattrSetprotocol(ScePthreadMutexattr* attr, int protocol); +int PS4_SYSV_ABI scePthreadMutexLock(ScePthreadMutex* mutex); +int PS4_SYSV_ABI scePthreadMutexUnlock(ScePthreadMutex* mutex); /**** * Posix calls */ int PS4_SYSV_ABI posix_pthread_mutex_init(ScePthreadMutex* mutex, const ScePthreadMutexattr* attr); +int PS4_SYSV_ABI posix_pthread_mutex_lock(ScePthreadMutex* mutex); +int PS4_SYSV_ABI posix_pthread_mutex_unlock(ScePthreadMutex* mutex); void pthreadSymbolsRegister(Loader::SymbolsResolver* sym); } // namespace Core::Libraries::LibKernel From 7fcea3277d072e372c9c1dfb41c83791f7fa37b8 Mon Sep 17 00:00:00 2001 From: georgemoralis Date: Fri, 10 Nov 2023 23:30:28 +0200 Subject: [PATCH 05/14] some mutexlock , mutexunlock implementations --- src/core/hle/error_codes.h | 2 + .../libraries/libkernel/thread_management.cpp | 38 ++++++++++++++++++- 2 files changed, 38 insertions(+), 2 deletions(-) diff --git a/src/core/hle/error_codes.h b/src/core/hle/error_codes.h index cdb26407..3794432a 100644 --- a/src/core/hle/error_codes.h +++ b/src/core/hle/error_codes.h @@ -2,7 +2,9 @@ constexpr int SCE_OK = 0; +constexpr int SCE_KERNEL_ERROR_EPERM = 0x80020001; constexpr int SCE_KERNEL_ERROR_EBADF = 0x80020009; +constexpr int SCE_KERNEL_ERROR_EDEADLK = 0x8002000B; constexpr int SCE_KERNEL_ERROR_ENOMEM = 0x8002000c; // Insufficient memory constexpr int SCE_KERNEL_ERROR_EFAULT = 0x8002000e; // Invalid address pointer constexpr int SCE_KERNEL_ERROR_EINVAL = 0x80020016; // null or invalid states diff --git a/src/core/hle/libraries/libkernel/thread_management.cpp b/src/core/hle/libraries/libkernel/thread_management.cpp index 35b6b990..e8a7003e 100644 --- a/src/core/hle/libraries/libkernel/thread_management.cpp +++ b/src/core/hle/libraries/libkernel/thread_management.cpp @@ -133,6 +133,8 @@ int PS4_SYSV_ABI scePthreadMutexInit(ScePthreadMutex* mutex, const ScePthreadMut *mutex = new PthreadMutexInternal{}; if (name != nullptr) { (*mutex)->name = name; + } else { + (*mutex)->name = "dummy"; } int result = pthread_mutex_init(&(*mutex)->pth_mutex, &(*attr)->pth_mutex_attr); @@ -193,8 +195,39 @@ int PS4_SYSV_ABI scePthreadMutexattrSetprotocol(ScePthreadMutexattr* attr, int p return result == 0 ? SCE_OK : SCE_KERNEL_ERROR_EINVAL; } -int PS4_SYSV_ABI scePthreadMutexLock(ScePthreadMutex* mutex) {} -int PS4_SYSV_ABI scePthreadMutexUnlock(ScePthreadMutex* mutex) {} +int PS4_SYSV_ABI scePthreadMutexLock(ScePthreadMutex* mutex) { + PRINT_FUNCTION_NAME(); + if (mutex == nullptr) { + return SCE_KERNEL_ERROR_EINVAL; + } + + int result = pthread_mutex_lock(&(*mutex)->pth_mutex); + printf("mutex lock: %s, %d\n", (*mutex)->name.c_str(), result); + switch (result) { + case 0: return SCE_OK; + case EAGAIN: return SCE_KERNEL_ERROR_EAGAIN; + case EINVAL: return SCE_KERNEL_ERROR_EINVAL; + case EDEADLK: return SCE_KERNEL_ERROR_EDEADLK; + default: return SCE_KERNEL_ERROR_EINVAL; + } +} +int PS4_SYSV_ABI scePthreadMutexUnlock(ScePthreadMutex* mutex) { + PRINT_FUNCTION_NAME(); + + if (mutex == nullptr) { + return SCE_KERNEL_ERROR_EINVAL; + } + + int result = pthread_mutex_unlock(&(*mutex)->pth_mutex); + printf("mutex unlock: %s, %d\n", (*mutex)->name.c_str(), result); + switch (result) { + case 0: return SCE_OK; + + case EINVAL: return SCE_KERNEL_ERROR_EINVAL; + case EPERM: return SCE_KERNEL_ERROR_EPERM; + default: return SCE_KERNEL_ERROR_EINVAL; + } +} int PS4_SYSV_ABI posix_pthread_mutex_init(ScePthreadMutex* mutex, const ScePthreadMutexattr* attr) { LOG_INFO_IF(log_pthread_file, "posix pthread_mutex_init redirect to scePthreadMutexInit\n"); @@ -236,6 +269,7 @@ void pthreadSymbolsRegister(Loader::SymbolsResolver* sym) { LIB_FUNCTION("9UK1vLZQft4", "libkernel", 1, "libkernel", 1, 1, scePthreadMutexLock); LIB_FUNCTION("tn3VlD0hG60", "libkernel", 1, "libkernel", 1, 1, scePthreadMutexUnlock); // posix calls + 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); } From 5f825fc8a8fc64e5b2effe8b3b8fa7f8212d140c Mon Sep 17 00:00:00 2001 From: georgemoralis Date: Sat, 11 Nov 2023 09:45:47 +0200 Subject: [PATCH 06/14] implemented posix error return codes --- src/core/hle/libraries/libkernel/thread_management.cpp | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/src/core/hle/libraries/libkernel/thread_management.cpp b/src/core/hle/libraries/libkernel/thread_management.cpp index e8a7003e..531add18 100644 --- a/src/core/hle/libraries/libkernel/thread_management.cpp +++ b/src/core/hle/libraries/libkernel/thread_management.cpp @@ -233,7 +233,8 @@ int PS4_SYSV_ABI posix_pthread_mutex_init(ScePthreadMutex* mutex, const ScePthre LOG_INFO_IF(log_pthread_file, "posix pthread_mutex_init redirect to scePthreadMutexInit\n"); int result = scePthreadMutexInit(mutex, attr, nullptr); if (result < 0) { - BREAKPOINT(); // posix calls different only for their return values + int rt = result > 0x80020000 && result <= 0x80020065 ? result + -0x80020000 : 1062; + return rt; } return result; } @@ -242,7 +243,8 @@ int PS4_SYSV_ABI posix_pthread_mutex_lock(ScePthreadMutex* mutex) { LOG_INFO_IF(log_pthread_file, "posix pthread_mutex_lock redirect to scePthreadMutexLock\n"); int result = scePthreadMutexLock(mutex); if (result < 0) { - BREAKPOINT(); // posix calls different only for their return values + int rt = result > 0x80020000 && result <= 0x80020065 ? result + -0x80020000 : 1062; + return rt; } return result; } @@ -251,7 +253,8 @@ int PS4_SYSV_ABI posix_pthread_mutex_unlock(ScePthreadMutex* mutex) { LOG_INFO_IF(log_pthread_file, "posix pthread_mutex_unlock redirect to scePthreadMutexUnlock\n"); int result = scePthreadMutexUnlock(mutex); if (result < 0) { - BREAKPOINT(); // posix calls different only for their return values + int rt = result > 0x80020000 && result <= 0x80020065 ? result + -0x80020000 : 1062; + return rt; } return result; } From dbaf38dc7dcec672b2eac254f8f2d7ebeb12b51d Mon Sep 17 00:00:00 2001 From: georgemoralis Date: Sat, 11 Nov 2023 10:01:16 +0200 Subject: [PATCH 07/14] mutex debugging log --- src/core/hle/libraries/libkernel/thread_management.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/core/hle/libraries/libkernel/thread_management.cpp b/src/core/hle/libraries/libkernel/thread_management.cpp index 531add18..a5074865 100644 --- a/src/core/hle/libraries/libkernel/thread_management.cpp +++ b/src/core/hle/libraries/libkernel/thread_management.cpp @@ -134,7 +134,7 @@ int PS4_SYSV_ABI scePthreadMutexInit(ScePthreadMutex* mutex, const ScePthreadMut if (name != nullptr) { (*mutex)->name = name; } else { - (*mutex)->name = "dummy"; + (*mutex)->name = "noname"; } int result = pthread_mutex_init(&(*mutex)->pth_mutex, &(*attr)->pth_mutex_attr); @@ -202,7 +202,7 @@ int PS4_SYSV_ABI scePthreadMutexLock(ScePthreadMutex* mutex) { } int result = pthread_mutex_lock(&(*mutex)->pth_mutex); - printf("mutex lock: %s, %d\n", (*mutex)->name.c_str(), result); + LOG_INFO_IF(log_pthread_file, "scePthreadMutexLock name={} result={}\n", (*mutex)->name, result); switch (result) { case 0: return SCE_OK; case EAGAIN: return SCE_KERNEL_ERROR_EAGAIN; @@ -219,7 +219,7 @@ int PS4_SYSV_ABI scePthreadMutexUnlock(ScePthreadMutex* mutex) { } int result = pthread_mutex_unlock(&(*mutex)->pth_mutex); - printf("mutex unlock: %s, %d\n", (*mutex)->name.c_str(), result); + LOG_INFO_IF(log_pthread_file, "scePthreadMutexUnlock name={} result={}\n", (*mutex)->name, result); switch (result) { case 0: return SCE_OK; From 402ee7d006df99d336db9a23426b309382bce48e Mon Sep 17 00:00:00 2001 From: georgemoralis Date: Sat, 11 Nov 2023 10:49:44 +0200 Subject: [PATCH 08/14] init mutex if it doesn't exist when trying to lock (found in openorbis) --- .../hle/libraries/libkernel/thread_management.cpp | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/src/core/hle/libraries/libkernel/thread_management.cpp b/src/core/hle/libraries/libkernel/thread_management.cpp index a5074865..82e6d00a 100644 --- a/src/core/hle/libraries/libkernel/thread_management.cpp +++ b/src/core/hle/libraries/libkernel/thread_management.cpp @@ -140,7 +140,7 @@ int PS4_SYSV_ABI scePthreadMutexInit(ScePthreadMutex* mutex, const ScePthreadMut int result = pthread_mutex_init(&(*mutex)->pth_mutex, &(*attr)->pth_mutex_attr); if (name != nullptr) { - LOG_INFO_IF(log_pthread_file, "mutex_init name={},result={}\n"); + LOG_INFO_IF(log_pthread_file, "mutex_init name={},result={}\n",name,result); } switch (result) { @@ -197,6 +197,10 @@ int PS4_SYSV_ABI scePthreadMutexattrSetprotocol(ScePthreadMutexattr* attr, int p } int PS4_SYSV_ABI scePthreadMutexLock(ScePthreadMutex* mutex) { PRINT_FUNCTION_NAME(); + if (mutex != nullptr || *static_cast((void*)mutex) == nullptr) { + scePthreadMutexInit(mutex, nullptr, "nomame"); // init mutex if it doesn't exist + } + if (mutex == nullptr) { return SCE_KERNEL_ERROR_EINVAL; } @@ -213,7 +217,9 @@ int PS4_SYSV_ABI scePthreadMutexLock(ScePthreadMutex* mutex) { } int PS4_SYSV_ABI scePthreadMutexUnlock(ScePthreadMutex* mutex) { PRINT_FUNCTION_NAME(); - + if (mutex != nullptr || *static_cast((void*)mutex) == nullptr) { + scePthreadMutexInit(mutex, nullptr, "nomame"); // init mutex if it doesn't exist this probably won't need + } if (mutex == nullptr) { return SCE_KERNEL_ERROR_EINVAL; } @@ -275,6 +281,9 @@ void pthreadSymbolsRegister(Loader::SymbolsResolver* sym) { 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); + + // openorbis weird functions + LIB_FUNCTION("7H0iTOciTLo", "libkernel", 1, "libkernel", 1, 1, posix_pthread_mutex_lock); } } // namespace Core::Libraries::LibKernel From 7f0cf8784b60d23f9100ceb0bfdf4a907b7e888a Mon Sep 17 00:00:00 2001 From: georgemoralis Date: Sat, 11 Nov 2023 12:13:43 +0200 Subject: [PATCH 09/14] improved mutex creation --- .../hle/libraries/libkernel/libkernel.cpp | 23 ++++++++++--------- src/core/hle/libraries/libkernel/libkernel.h | 4 +++- .../libraries/libkernel/thread_management.cpp | 21 ++++++++++++----- 3 files changed, 30 insertions(+), 18 deletions(-) diff --git a/src/core/hle/libraries/libkernel/libkernel.cpp b/src/core/hle/libraries/libkernel/libkernel.cpp index 7ab71291..52e1a8e6 100644 --- a/src/core/hle/libraries/libkernel/libkernel.cpp +++ b/src/core/hle/libraries/libkernel/libkernel.cpp @@ -1,15 +1,16 @@ -#include "common/log.h" +#include "core/hle/libraries/libkernel/libkernel.h" + #include "common/debug.h" +#include "common/log.h" #include "common/singleton.h" -#include "core/loader/elf.h" #include "core/hle/kernel/Objects/physical_memory.h" #include "core/hle/kernel/cpu_management.h" #include "core/hle/kernel/event_queues.h" #include "core/hle/kernel/memory_management.h" -#include "core/hle/libraries/libkernel/libkernel.h" #include "core/hle/libraries/libkernel/file_system.h" #include "core/hle/libraries/libkernel/time_management.h" #include "core/hle/libraries/libs.h" +#include "core/loader/elf.h" #ifdef _WIN64 #include @@ -25,13 +26,12 @@ int32_t PS4_SYSV_ABI sceKernelReleaseDirectMemory(off_t start, size_t len) { return 0; } -static PS4_SYSV_ABI void stack_chk_fail() { - BREAKPOINT(); -} +static PS4_SYSV_ABI void stack_chk_fail() { BREAKPOINT(); } -int PS4_SYSV_ABI sceKernelMunmap(void* addr, size_t len) { - BREAKPOINT(); -} +int PS4_SYSV_ABI sceKernelMunmap(void* addr, size_t len) { BREAKPOINT(); } + +static thread_local int libc_error; +int* PS4_SYSV_ABI __Error() { return &libc_error; } void LibKernel_Register(Loader::SymbolsResolver* sym) { // obj @@ -48,10 +48,11 @@ void LibKernel_Register(Loader::SymbolsResolver* sym) { // misc LIB_FUNCTION("WslcK1FQcGI", "libkernel", 1, "libkernel", 1, 1, Kernel::sceKernelIsNeoMode); LIB_FUNCTION("Ou3iL1abvng", "libkernel", 1, "libkernel", 1, 1, stack_chk_fail); - + LIB_FUNCTION("9BcDykPmo1I", "libkernel", 1, "libkernel", 1, 1, __Error); + Core::Libraries::LibKernel::fileSystemSymbolsRegister(sym); Core::Libraries::LibKernel::timeSymbolsRegister(sym); Core::Libraries::LibKernel::pthreadSymbolsRegister(sym); } -} // namespace Core::Libraries::LibKernel +} // namespace Core::Libraries::LibKernel diff --git a/src/core/hle/libraries/libkernel/libkernel.h b/src/core/hle/libraries/libkernel/libkernel.h index a10adbb3..2d65a54d 100644 --- a/src/core/hle/libraries/libkernel/libkernel.h +++ b/src/core/hle/libraries/libkernel/libkernel.h @@ -1,6 +1,7 @@ #pragma once #include + #include "common/types.h" namespace Core::Loader { @@ -10,7 +11,8 @@ class SymbolsResolver; namespace Core::Libraries::LibKernel { int32_t PS4_SYSV_ABI sceKernelReleaseDirectMemory(off_t start, size_t len); +int* PS4_SYSV_ABI __Error(); void LibKernel_Register(Loader::SymbolsResolver* sym); -} // namespace Core::Libraries::LibKernel +} // namespace Core::Libraries::LibKernel diff --git a/src/core/hle/libraries/libkernel/thread_management.cpp b/src/core/hle/libraries/libkernel/thread_management.cpp index 82e6d00a..36755737 100644 --- a/src/core/hle/libraries/libkernel/thread_management.cpp +++ b/src/core/hle/libraries/libkernel/thread_management.cpp @@ -151,6 +151,18 @@ int PS4_SYSV_ABI scePthreadMutexInit(ScePthreadMutex* mutex, const ScePthreadMut default: return SCE_KERNEL_ERROR_EINVAL; } } + +void* createMutex(void* addr) { + if (addr == nullptr || *static_cast(addr) != nullptr) { + return addr; + } + auto vaddr = reinterpret_cast(addr); + + std::string name = fmt::format("mutex{:#x}",vaddr); + scePthreadMutexInit(static_cast(addr), nullptr, name.c_str()); + return addr; +} + int PS4_SYSV_ABI scePthreadMutexattrInit(ScePthreadMutexattr* attr) { *attr = new PthreadMutexattrInternal{}; @@ -197,9 +209,7 @@ int PS4_SYSV_ABI scePthreadMutexattrSetprotocol(ScePthreadMutexattr* attr, int p } int PS4_SYSV_ABI scePthreadMutexLock(ScePthreadMutex* mutex) { PRINT_FUNCTION_NAME(); - if (mutex != nullptr || *static_cast((void*)mutex) == nullptr) { - scePthreadMutexInit(mutex, nullptr, "nomame"); // init mutex if it doesn't exist - } + mutex = static_cast(createMutex(mutex)); if (mutex == nullptr) { return SCE_KERNEL_ERROR_EINVAL; @@ -217,9 +227,7 @@ int PS4_SYSV_ABI scePthreadMutexLock(ScePthreadMutex* mutex) { } int PS4_SYSV_ABI scePthreadMutexUnlock(ScePthreadMutex* mutex) { PRINT_FUNCTION_NAME(); - if (mutex != nullptr || *static_cast((void*)mutex) == nullptr) { - scePthreadMutexInit(mutex, nullptr, "nomame"); // init mutex if it doesn't exist this probably won't need - } + mutex = static_cast(createMutex(mutex)); if (mutex == nullptr) { return SCE_KERNEL_ERROR_EINVAL; } @@ -284,6 +292,7 @@ void pthreadSymbolsRegister(Loader::SymbolsResolver* sym) { // openorbis weird functions 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); } } // namespace Core::Libraries::LibKernel From 7e6c741ed73527f729f85f6fc4c846a537c281b2 Mon Sep 17 00:00:00 2001 From: georgemoralis Date: Sat, 11 Nov 2023 16:25:53 +0200 Subject: [PATCH 10/14] added sceSystemServiceGetStatus --- .../libsystemservice/system_service.cpp | 23 +++++++++++++++---- .../libsystemservice/system_service.h | 13 ++++++++++- 2 files changed, 30 insertions(+), 6 deletions(-) diff --git a/src/core/hle/libraries/libsystemservice/system_service.cpp b/src/core/hle/libraries/libsystemservice/system_service.cpp index 85023606..314dae47 100644 --- a/src/core/hle/libraries/libsystemservice/system_service.cpp +++ b/src/core/hle/libraries/libsystemservice/system_service.cpp @@ -1,7 +1,8 @@ +#include "core/hle/libraries/libsystemservice/system_service.h" + #include "common/log.h" #include "core/hle/error_codes.h" #include "core/hle/libraries/libs.h" -#include "core/hle/libraries/libsystemservice/system_service.h" namespace Core::Libraries::LibSystemService { @@ -10,9 +11,21 @@ s32 PS4_SYSV_ABI sceSystemServiceHideSplashScreen() { return SCE_OK; } -void systemServiceSymbolsRegister(Loader::SymbolsResolver* sym) { - LIB_FUNCTION("Vo5V8KAwCmk", "libSceSystemService", 1, "libSceSystemService", 1, 1, - sceSystemServiceHideSplashScreen); +s32 PS4_SYSV_ABI sceSystemServiceGetStatus(SceSystemServiceStatus* status) { + SceSystemServiceStatus st = {}; + st.eventNum = 0; + st.isSystemUiOverlaid = false; + st.isInBackgroundExecution = false; + st.isCpuMode7CpuNormal = true; + st.isGameLiveStreamingOnAir = false; + st.isOutOfVrPlayArea = false; + *status = st; + return SCE_OK; } -}; // namespace Core::Libraries::LibSystemService +void systemServiceSymbolsRegister(Loader::SymbolsResolver* sym) { + LIB_FUNCTION("Vo5V8KAwCmk", "libSceSystemService", 1, "libSceSystemService", 1, 1, sceSystemServiceHideSplashScreen); + LIB_FUNCTION("rPo6tV8D9bM", "libSceSystemService", 1, "libSceSystemService", 1, 1, sceSystemServiceGetStatus); +} + +}; // namespace Core::Libraries::LibSystemService diff --git a/src/core/hle/libraries/libsystemservice/system_service.h b/src/core/hle/libraries/libsystemservice/system_service.h index 1b31cab3..af2e358d 100644 --- a/src/core/hle/libraries/libsystemservice/system_service.h +++ b/src/core/hle/libraries/libsystemservice/system_service.h @@ -8,8 +8,19 @@ class SymbolsResolver; namespace Core::Libraries::LibSystemService { +struct SceSystemServiceStatus { + s32 eventNum; + bool isSystemUiOverlaid; + bool isInBackgroundExecution; + bool isCpuMode7CpuNormal; + bool isGameLiveStreamingOnAir; + bool isOutOfVrPlayArea; + u08 reserved[]; +}; + s32 PS4_SYSV_ABI sceSystemServiceHideSplashScreen(); +s32 PS4_SYSV_ABI sceSystemServiceGetStatus(SceSystemServiceStatus* status); void systemServiceSymbolsRegister(Loader::SymbolsResolver* sym); -}; // namespace Core::Libraries::LibSystemService +}; // namespace Core::Libraries::LibSystemService From e8c425850eba8d8052975402e960a7b53b4fc52e Mon Sep 17 00:00:00 2001 From: wheremyfoodat <44909372+wheremyfoodat@users.noreply.github.com> Date: Sun, 12 Nov 2023 10:57:50 +0200 Subject: [PATCH 11/14] some adjustments --- src/core/hle/libraries/libkernel/thread_management.cpp | 4 ++-- src/core/hle/libraries/libkernel/thread_management.h | 3 ++- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/src/core/hle/libraries/libkernel/thread_management.cpp b/src/core/hle/libraries/libkernel/thread_management.cpp index 36755737..37aa1190 100644 --- a/src/core/hle/libraries/libkernel/thread_management.cpp +++ b/src/core/hle/libraries/libkernel/thread_management.cpp @@ -20,7 +20,7 @@ void init_pthreads() { g_pthread_cxt->setDefaultMutexattr(default_mutexattr); } -void Pthread_Init_Self_MainThread() { +void pthreadInitSelfMainThread() { scePthreadAttrInit(&g_pthread_self.attr); g_pthread_self.pth = pthread_self(); g_pthread_self.name = "Main_Thread"; @@ -158,7 +158,7 @@ void* createMutex(void* addr) { } auto vaddr = reinterpret_cast(addr); - std::string name = fmt::format("mutex{:#x}",vaddr); + std::string name = fmt::format("mutex{:#}",vaddr); scePthreadMutexInit(static_cast(addr), nullptr, name.c_str()); return addr; } diff --git a/src/core/hle/libraries/libkernel/thread_management.h b/src/core/hle/libraries/libkernel/thread_management.h index be79a4ce..da68d8a0 100644 --- a/src/core/hle/libraries/libkernel/thread_management.h +++ b/src/core/hle/libraries/libkernel/thread_management.h @@ -59,8 +59,9 @@ class PThreadCxt { private: ScePthreadMutexattr m_default_mutexattr = nullptr; }; + void init_pthreads(); -void Pthread_Init_Self_MainThread(); +void pthreadInitSelfMainThread(); int PS4_SYSV_ABI scePthreadAttrInit(ScePthreadAttr* attr); int PS4_SYSV_ABI scePthreadAttrSetdetachstate(ScePthreadAttr* attr, int detachstate); From ae12f351f8c1c646b59a24f16d5b56ba7a4856aa Mon Sep 17 00:00:00 2001 From: georgemoralis Date: Sun, 12 Nov 2023 13:23:35 +0200 Subject: [PATCH 12/14] better posix errors --- src/core/hle/error_codes.h | 229 +++++++++++++++++- .../libraries/libkernel/thread_management.cpp | 12 +- src/core/linker.cpp | 2 +- 3 files changed, 231 insertions(+), 12 deletions(-) diff --git a/src/core/hle/error_codes.h b/src/core/hle/error_codes.h index 3794432a..80f0de40 100644 --- a/src/core/hle/error_codes.h +++ b/src/core/hle/error_codes.h @@ -1,15 +1,234 @@ #pragma once +// posix error codes +constexpr int POSIX_EPERM = 1; +constexpr int POSIX_ENOENT = 2; +constexpr int POSIX_ESRCH = 3; +constexpr int POSIX_EINTR = 4; +constexpr int POSIX_EIO = 5; +constexpr int POSIX_ENXIO = 6; +constexpr int POSIX_E2BIG = 7; +constexpr int POSIX_ENOEXEC = 8; +constexpr int POSIX_EBADF = 9; +constexpr int POSIX_ECHILD = 10; +constexpr int POSIX_EDEADLK = 11; +constexpr int POSIX_ENOMEM = 12; +constexpr int POSIX_EACCES = 13; +constexpr int POSIX_EFAULT = 14; +constexpr int POSIX_ENOTBLK = 15; +constexpr int POSIX_EBUSY = 16; +constexpr int POSIX_EEXIST = 17; +constexpr int POSIX_EXDEV = 18; +constexpr int POSIX_ENODEV = 19; +constexpr int POSIX_ENOTDIR = 20; +constexpr int POSIX_EISDIR = 21; +constexpr int POSIX_EINVAL = 22; +constexpr int POSIX_ENFILE = 23; +constexpr int POSIX_EMFILE = 24; +constexpr int POSIX_ENOTTY = 25; +constexpr int POSIX_ETXTBSY = 26; +constexpr int POSIX_EFBIG = 27; +constexpr int POSIX_ENOSPC = 28; +constexpr int POSIX_ESPIPE = 29; +constexpr int POSIX_EROFS = 30; +constexpr int POSIX_EMLINK = 31; +constexpr int POSIX_EPIPE = 32; +constexpr int POSIX_EDOM = 33; +constexpr int POSIX_ERANGE = 34; +constexpr int POSIX_EAGAIN = 35; +constexpr int POSIX_EWOULDBLOCK = 35; +constexpr int POSIX_EINPROGRESS = 36; +constexpr int POSIX_EALREADY = 37; +constexpr int POSIX_ENOTSOCK = 38; +constexpr int POSIX_EDESTADDRREQ = 39; +constexpr int POSIX_EMSGSIZE = 40; +constexpr int POSIX_EPROTOTYPE = 41; +constexpr int POSIX_ENOPROTOOPT = 42; +constexpr int POSIX_EPROTONOSUPPORT = 43; +constexpr int POSIX_ESOCKTNOSUPPORT = 44; +constexpr int POSIX_EOPNOTSUPP = 45; +constexpr int POSIX_ENOTSUP = 45; +constexpr int POSIX_EPFNOSUPPORT = 46; +constexpr int POSIX_EAFNOSUPPORT = 47; +constexpr int POSIX_EADDRINUSE = 48; +constexpr int POSIX_EADDRNOTAVAIL = 49; +constexpr int POSIX_ENETDOWN = 50; +constexpr int POSIX_ENETUNREACH = 51; +constexpr int POSIX_ENETRESET = 52; +constexpr int POSIX_ECONNABORTED = 53; +constexpr int POSIX_ECONNRESET = 54; +constexpr int POSIX_ENOBUFS = 55; +constexpr int POSIX_EISCONN = 56; +constexpr int POSIX_ENOTCONN = 57; +constexpr int POSIX_ESHUTDOWN = 58; +constexpr int POSIX_ETOOMANYREFS = 59; +constexpr int POSIX_ETIMEDOUT = 60; +constexpr int POSIX_ECONNREFUSED = 61; +constexpr int POSIX_ELOOP = 62; +constexpr int POSIX_ENAMETOOLONG = 63; +constexpr int POSIX_EHOSTDOWN = 64; +constexpr int POSIX_EHOSTUNREACH = 65; +constexpr int POSIX_ENOTEMPTY = 66; +constexpr int POSIX_EPROCLIM = 67; +constexpr int POSIX_EUSERS = 68; +constexpr int POSIX_EDQUOT = 69; +constexpr int POSIX_ESTALE = 70; +constexpr int POSIX_EREMOTE = 71; +constexpr int POSIX_EBADRPC = 72; +constexpr int POSIX_ERPCMISMATCH = 73; +constexpr int POSIX_EPROGUNAVAIL = 74; +constexpr int POSIX_EPROGMISMATCH = 75; +constexpr int POSIX_EPROCUNAVAIL = 76; +constexpr int POSIX_ENOLCK = 77; +constexpr int POSIX_ENOSYS = 78; +constexpr int POSIX_EFTYPE = 79; +constexpr int POSIX_EAUTH = 80; +constexpr int POSIX_ENEEDAUTH = 81; +constexpr int POSIX_EIDRM = 82; +constexpr int POSIX_ENOMSG = 83; +constexpr int POSIX_EOVERFLOW = 84; +constexpr int POSIX_ECANCELED = 85; +constexpr int POSIX_EILSEQ = 86; +constexpr int POSIX_ENOATTR = 87; +constexpr int POSIX_EDOOFUS = 88; +constexpr int POSIX_EBADMSG = 89; +constexpr int POSIX_EMULTIHOP = 90; +constexpr int POSIX_ENOLINK = 91; +constexpr int POSIX_EPROTO = 92; +constexpr int POSIX_ENOTCAPABLE = 93; +constexpr int POSIX_ECAPMODE = 94; +constexpr int POSIX_ENOBLK = 95; +constexpr int POSIX_EICV = 96; +constexpr int POSIX_ENOPLAYGOENT = 97; +constexpr int POSIX_EREVOKE = 98; +constexpr int POSIX_ESDKVERSION = 99; +constexpr int POSIX_ESTART = 100; +constexpr int POSIX_ESTOP = 101; +constexpr int POSIX_EINVALID2MB = 102; +constexpr int POSIX_ELAST = 102; +constexpr int POSIX_EADHOC = 160; +constexpr int POSIX_EINACTIVEDISABLED = 163; +constexpr int POSIX_ENETNODATA = 164; +constexpr int POSIX_ENETDESC = 165; +constexpr int POSIX_ENETDESCTIMEDOUT = 166; +constexpr int POSIX_ENETINTR = 167; +constexpr int POSIX_ERETURN = 205; +constexpr int POSIX_EFPOS = 152; +constexpr int POSIX_ENODATA = 1040; +constexpr int POSIX_ENOSR = 1050; +constexpr int POSIX_ENOSTR = 1051; +constexpr int POSIX_ENOTRECOVERABLE = 1056; +constexpr int POSIX_EOTHER = 1062; +constexpr int POSIX_EOWNERDEAD = 1064; +constexpr int POSIX_ETIME = 1074; + constexpr int SCE_OK = 0; +// kernel error codes +constexpr int SCE_KERNEL_ERROR_UNKNOWN = 0x80020000; constexpr int SCE_KERNEL_ERROR_EPERM = 0x80020001; +constexpr int SCE_KERNEL_ERROR_ENOENT = 0x80020002; +constexpr int SCE_KERNEL_ERROR_ESRCH = 0x80020003; +constexpr int SCE_KERNEL_ERROR_EINTR = 0x80020004; +constexpr int SCE_KERNEL_ERROR_EIO = 0x80020005; +constexpr int SCE_KERNEL_ERROR_ENXIO = 0x80020006; +constexpr int SCE_KERNEL_ERROR_E2BIG = 0x80020007; +constexpr int SCE_KERNEL_ERROR_ENOEXEC = 0x80020008; constexpr int SCE_KERNEL_ERROR_EBADF = 0x80020009; +constexpr int SCE_KERNEL_ERROR_ECHILD = 0x8002000A; constexpr int SCE_KERNEL_ERROR_EDEADLK = 0x8002000B; -constexpr int SCE_KERNEL_ERROR_ENOMEM = 0x8002000c; // Insufficient memory -constexpr int SCE_KERNEL_ERROR_EFAULT = 0x8002000e; // Invalid address pointer -constexpr int SCE_KERNEL_ERROR_EINVAL = 0x80020016; // null or invalid states -constexpr int SCE_KERNEL_ERROR_EAGAIN = 0x80020023; // Memory cannot be allocated -constexpr int SCE_KERNEL_ERROR_ENAMETOOLONG = 0x8002003f; // character strings exceeds valid size +constexpr int SCE_KERNEL_ERROR_ENOMEM = 0x8002000C; +constexpr int SCE_KERNEL_ERROR_EACCES = 0x8002000D; +constexpr int SCE_KERNEL_ERROR_EFAULT = 0x8002000E; +constexpr int SCE_KERNEL_ERROR_ENOTBLK = 0x8002000F; +constexpr int SCE_KERNEL_ERROR_EBUSY = 0x80020010; +constexpr int SCE_KERNEL_ERROR_EEXIST = 0x80020011; +constexpr int SCE_KERNEL_ERROR_EXDEV = 0x80020012; +constexpr int SCE_KERNEL_ERROR_ENODEV = 0x80020013; +constexpr int SCE_KERNEL_ERROR_ENOTDIR = 0x80020014; +constexpr int SCE_KERNEL_ERROR_EISDIR = 0x80020015; +constexpr int SCE_KERNEL_ERROR_EINVAL = 0x80020016; +constexpr int SCE_KERNEL_ERROR_ENFILE = 0x80020017; +constexpr int SCE_KERNEL_ERROR_EMFILE = 0x80020018; +constexpr int SCE_KERNEL_ERROR_ENOTTY = 0x80020019; +constexpr int SCE_KERNEL_ERROR_ETXTBSY = 0x8002001A; +constexpr int SCE_KERNEL_ERROR_EFBIG = 0x8002001B; +constexpr int SCE_KERNEL_ERROR_ENOSPC = 0x8002001C; +constexpr int SCE_KERNEL_ERROR_ESPIPE = 0x8002001D; +constexpr int SCE_KERNEL_ERROR_EROFS = 0x8002001E; +constexpr int SCE_KERNEL_ERROR_EMLINK = 0x8002001F; +constexpr int SCE_KERNEL_ERROR_EPIPE = 0x80020020; +constexpr int SCE_KERNEL_ERROR_EDOM = 0x80020021; +constexpr int SCE_KERNEL_ERROR_ERANGE = 0x80020022; +constexpr int SCE_KERNEL_ERROR_EAGAIN = 0x80020023; +constexpr int SCE_KERNEL_ERROR_EWOULDBLOCK = 0x80020023; +constexpr int SCE_KERNEL_ERROR_EINPROGRESS = 0x80020024; +constexpr int SCE_KERNEL_ERROR_EALREADY = 0x80020025; +constexpr int SCE_KERNEL_ERROR_ENOTSOCK = 0x80020026; +constexpr int SCE_KERNEL_ERROR_EDESTADDRREQ = 0x80020027; +constexpr int SCE_KERNEL_ERROR_EMSGSIZE = 0x80020028; +constexpr int SCE_KERNEL_ERROR_EPROTOTYPE = 0x80020029; +constexpr int SCE_KERNEL_ERROR_ENOPROTOOPT = 0x8002002A; +constexpr int SCE_KERNEL_ERROR_EPROTONOSUPPORT = 0x8002002B; +constexpr int SCE_KERNEL_ERROR_ESOCKTNOSUPPORT = 0x8002002C; +constexpr int SCE_KERNEL_ERROR_EOPNOTSUPP = 0x8002002D; +constexpr int SCE_KERNEL_ERROR_ENOTSUP = 0x8002002D; +constexpr int SCE_KERNEL_ERROR_EPFNOSUPPORT = 0x8002002E; +constexpr int SCE_KERNEL_ERROR_EAFNOSUPPORT = 0x8002002F; +constexpr int SCE_KERNEL_ERROR_EADDRINUSE = 0x80020030; +constexpr int SCE_KERNEL_ERROR_EADDRNOTAVAIL = 0x80020031; +constexpr int SCE_KERNEL_ERROR_ENETDOWN = 0x80020032; +constexpr int SCE_KERNEL_ERROR_ENETUNREACH = 0x80020033; +constexpr int SCE_KERNEL_ERROR_ENETRESET = 0x80020034; +constexpr int SCE_KERNEL_ERROR_ECONNABORTED = 0x80020035; +constexpr int SCE_KERNEL_ERROR_ECONNRESET = 0x80020036; +constexpr int SCE_KERNEL_ERROR_ENOBUFS = 0x80020037; +constexpr int SCE_KERNEL_ERROR_EISCONN = 0x80020038; +constexpr int SCE_KERNEL_ERROR_ENOTCONN = 0x80020039; +constexpr int SCE_KERNEL_ERROR_ESHUTDOWN = 0x8002003A; +constexpr int SCE_KERNEL_ERROR_ETOOMANYREFS = 0x8002003B; +constexpr int SCE_KERNEL_ERROR_ETIMEDOUT = 0x8002003C; +constexpr int SCE_KERNEL_ERROR_ECONNREFUSED = 0x8002003D; +constexpr int SCE_KERNEL_ERROR_ELOOP = 0x8002003E; +constexpr int SCE_KERNEL_ERROR_ENAMETOOLONG = 0x8002003F; +constexpr int SCE_KERNEL_ERROR_EHOSTDOWN = 0x80020040; +constexpr int SCE_KERNEL_ERROR_EHOSTUNREACH = 0x80020041; +constexpr int SCE_KERNEL_ERROR_ENOTEMPTY = 0x80020042; +constexpr int SCE_KERNEL_ERROR_EPROCLIM = 0x80020043; +constexpr int SCE_KERNEL_ERROR_EUSERS = 0x80020044; +constexpr int SCE_KERNEL_ERROR_EDQUOT = 0x80020045; +constexpr int SCE_KERNEL_ERROR_ESTALE = 0x80020046; +constexpr int SCE_KERNEL_ERROR_EREMOTE = 0x80020047; +constexpr int SCE_KERNEL_ERROR_EBADRPC = 0x80020048; +constexpr int SCE_KERNEL_ERROR_ERPCMISMATCH = 0x80020049; +constexpr int SCE_KERNEL_ERROR_EPROGUNAVAIL = 0x8002004A; +constexpr int SCE_KERNEL_ERROR_EPROGMISMATCH = 0x8002004B; +constexpr int SCE_KERNEL_ERROR_EPROCUNAVAIL = 0x8002004C; +constexpr int SCE_KERNEL_ERROR_ENOLCK = 0x8002004D; +constexpr int SCE_KERNEL_ERROR_ENOSYS = 0x8002004E; +constexpr int SCE_KERNEL_ERROR_EFTYPE = 0x8002004F; +constexpr int SCE_KERNEL_ERROR_EAUTH = 0x80020050; +constexpr int SCE_KERNEL_ERROR_ENEEDAUTH = 0x80020051; +constexpr int SCE_KERNEL_ERROR_EIDRM = 0x80020052; +constexpr int SCE_KERNEL_ERROR_ENOMSG = 0x80020053; +constexpr int SCE_KERNEL_ERROR_EOVERFLOW = 0x80020054; +constexpr int SCE_KERNEL_ERROR_ECANCELED = 0x80020055; +constexpr int SCE_KERNEL_ERROR_EILSEQ = 0x80020056; +constexpr int SCE_KERNEL_ERROR_ENOATTR = 0x80020057; +constexpr int SCE_KERNEL_ERROR_EDOOFUS = 0x80020058; +constexpr int SCE_KERNEL_ERROR_EBADMSG = 0x80020059; +constexpr int SCE_KERNEL_ERROR_EMULTIHOP = 0x8002005A; +constexpr int SCE_KERNEL_ERROR_ENOLINK = 0x8002005B; +constexpr int SCE_KERNEL_ERROR_EPROTO = 0x8002005C; +constexpr int SCE_KERNEL_ERROR_ENOTCAPABLE = 0x8002005D; +constexpr int SCE_KERNEL_ERROR_ECAPMODE = 0x8002005E; +constexpr int SCE_KERNEL_ERROR_ENOBLK = 0x8002005F; +constexpr int SCE_KERNEL_ERROR_EICV = 0x80020060; +constexpr int SCE_KERNEL_ERROR_ENOPLAYGOENT = 0x80020061; +constexpr int SCE_KERNEL_ERROR_EREVOKE = 0x80020062; +constexpr int SCE_KERNEL_ERROR_ESDKVERSION = 0x80020063; +constexpr int SCE_KERNEL_ERROR_ESTART = 0x80020064; +constexpr int SCE_KERNEL_ERROR_ESTOP = 0x80020065; // videoOut constexpr int SCE_VIDEO_OUT_ERROR_INVALID_VALUE = 0x80290001; // invalid argument diff --git a/src/core/hle/libraries/libkernel/thread_management.cpp b/src/core/hle/libraries/libkernel/thread_management.cpp index 37aa1190..330b4b9b 100644 --- a/src/core/hle/libraries/libkernel/thread_management.cpp +++ b/src/core/hle/libraries/libkernel/thread_management.cpp @@ -140,7 +140,7 @@ int PS4_SYSV_ABI scePthreadMutexInit(ScePthreadMutex* mutex, const ScePthreadMut int result = pthread_mutex_init(&(*mutex)->pth_mutex, &(*attr)->pth_mutex_attr); if (name != nullptr) { - LOG_INFO_IF(log_pthread_file, "mutex_init name={},result={}\n",name,result); + LOG_INFO_IF(log_pthread_file, "mutex_init name={},result={}\n", name, result); } switch (result) { @@ -157,8 +157,8 @@ void* createMutex(void* addr) { return addr; } auto vaddr = reinterpret_cast(addr); - - std::string name = fmt::format("mutex{:#}",vaddr); + + std::string name = fmt::format("mutex{:#}", vaddr); scePthreadMutexInit(static_cast(addr), nullptr, name.c_str()); return addr; } @@ -247,7 +247,7 @@ int PS4_SYSV_ABI posix_pthread_mutex_init(ScePthreadMutex* mutex, const ScePthre LOG_INFO_IF(log_pthread_file, "posix pthread_mutex_init redirect to scePthreadMutexInit\n"); int result = scePthreadMutexInit(mutex, attr, nullptr); if (result < 0) { - int rt = result > 0x80020000 && result <= 0x80020065 ? result + -0x80020000 : 1062; + int rt = result > SCE_KERNEL_ERROR_UNKNOWN && result <= SCE_KERNEL_ERROR_ESTOP ? result + -SCE_KERNEL_ERROR_UNKNOWN : POSIX_EOTHER; return rt; } return result; @@ -257,7 +257,7 @@ int PS4_SYSV_ABI posix_pthread_mutex_lock(ScePthreadMutex* mutex) { LOG_INFO_IF(log_pthread_file, "posix pthread_mutex_lock redirect to scePthreadMutexLock\n"); int result = scePthreadMutexLock(mutex); if (result < 0) { - int rt = result > 0x80020000 && result <= 0x80020065 ? result + -0x80020000 : 1062; + int rt = result > SCE_KERNEL_ERROR_UNKNOWN && result <= SCE_KERNEL_ERROR_ESTOP ? result + -SCE_KERNEL_ERROR_UNKNOWN : POSIX_EOTHER; return rt; } return result; @@ -267,7 +267,7 @@ int PS4_SYSV_ABI posix_pthread_mutex_unlock(ScePthreadMutex* mutex) { LOG_INFO_IF(log_pthread_file, "posix pthread_mutex_unlock redirect to scePthreadMutexUnlock\n"); int result = scePthreadMutexUnlock(mutex); if (result < 0) { - int rt = result > 0x80020000 && result <= 0x80020065 ? result + -0x80020000 : 1062; + int rt = result > SCE_KERNEL_ERROR_UNKNOWN && result <= SCE_KERNEL_ERROR_ESTOP ? result + -SCE_KERNEL_ERROR_UNKNOWN : POSIX_EOTHER; return rt; } return result; diff --git a/src/core/linker.cpp b/src/core/linker.cpp index f9d619ff..77094b70 100644 --- a/src/core/linker.cpp +++ b/src/core/linker.cpp @@ -654,7 +654,7 @@ static void run_main_entry(u64 addr, EntryParams* params, exit_func_t exit_func) } void Linker::Execute() { - Core::Libraries::LibKernel::Pthread_Init_Self_MainThread(); + Core::Libraries::LibKernel::pthreadInitSelfMainThread(); EntryParams p{}; p.argc = 1; p.argv[0] = "eboot.bin"; //hmm should be ok? From 8f8f0757af8ef377cf9f5a159d259de39ce8661d Mon Sep 17 00:00:00 2001 From: georgemoralis Date: Sun, 12 Nov 2023 15:09:18 +0200 Subject: [PATCH 13/14] fixed issue in scePthreadAttrSetschedpolicy --- src/core/hle/libraries/libkernel/thread_management.cpp | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/core/hle/libraries/libkernel/thread_management.cpp b/src/core/hle/libraries/libkernel/thread_management.cpp index 330b4b9b..3930c66b 100644 --- a/src/core/hle/libraries/libkernel/thread_management.cpp +++ b/src/core/hle/libraries/libkernel/thread_management.cpp @@ -110,10 +110,12 @@ int PS4_SYSV_ABI scePthreadAttrSetschedpolicy(ScePthreadAttr* attr, int policy) } int ppolicy = SCHED_OTHER; // winpthreads only supports SCHED_OTHER - + if (policy != SCHED_OTHER) { + LOG_TRACE_IF(log_pthread_file, "scePthreadAttrSetschedpolicy policy={} not supported by winpthreads\n", policy); + } (*attr)->policy = policy; - int result = pthread_attr_setschedpolicy(&(*attr)->pth_attr, policy); + int result = pthread_attr_setschedpolicy(&(*attr)->pth_attr, ppolicy); return result == 0 ? SCE_OK : SCE_KERNEL_ERROR_EINVAL; } From f3c189feb3039b3cd4ce7eedc9b52205dc214624 Mon Sep 17 00:00:00 2001 From: georgemoralis Date: Sun, 12 Nov 2023 20:23:42 +0200 Subject: [PATCH 14/14] cleanup createMutex --- .../libraries/libkernel/thread_management.cpp | 22 +++++++++---------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/src/core/hle/libraries/libkernel/thread_management.cpp b/src/core/hle/libraries/libkernel/thread_management.cpp index 3930c66b..cdb2ec14 100644 --- a/src/core/hle/libraries/libkernel/thread_management.cpp +++ b/src/core/hle/libraries/libkernel/thread_management.cpp @@ -123,6 +123,17 @@ int PS4_SYSV_ABI scePthreadAttrSetschedpolicy(ScePthreadAttr* attr, int policy) /**** * Mutex calls */ +void* createMutex(void* addr) { + if (addr == nullptr || *static_cast(addr) != nullptr) { + return addr; + } + auto vaddr = reinterpret_cast(addr); + + std::string name = fmt::format("mutex{:#x}", vaddr); + scePthreadMutexInit(static_cast(addr), nullptr, name.c_str()); + return addr; +} + int PS4_SYSV_ABI scePthreadMutexInit(ScePthreadMutex* mutex, const ScePthreadMutexattr* attr, const char* name) { PRINT_FUNCTION_NAME(); if (mutex == nullptr) { @@ -154,17 +165,6 @@ int PS4_SYSV_ABI scePthreadMutexInit(ScePthreadMutex* mutex, const ScePthreadMut } } -void* createMutex(void* addr) { - if (addr == nullptr || *static_cast(addr) != nullptr) { - return addr; - } - auto vaddr = reinterpret_cast(addr); - - std::string name = fmt::format("mutex{:#}", vaddr); - scePthreadMutexInit(static_cast(addr), nullptr, name.c_str()); - return addr; -} - int PS4_SYSV_ABI scePthreadMutexattrInit(ScePthreadMutexattr* attr) { *attr = new PthreadMutexattrInternal{};