From cad5ac34b0853aea65b577984d6e3a98edb75827 Mon Sep 17 00:00:00 2001 From: georgemoralis Date: Thu, 16 Nov 2023 08:49:26 +0200 Subject: [PATCH 1/4] some threadman fixes --- .../libraries/libkernel/thread_management.cpp | 56 +++++++++++++++---- .../libraries/libkernel/thread_management.h | 10 +++- 2 files changed, 55 insertions(+), 11 deletions(-) diff --git a/src/core/hle/libraries/libkernel/thread_management.cpp b/src/core/hle/libraries/libkernel/thread_management.cpp index cdb2ec14..0e982e0b 100644 --- a/src/core/hle/libraries/libkernel/thread_management.cpp +++ b/src/core/hle/libraries/libkernel/thread_management.cpp @@ -8,7 +8,7 @@ namespace Core::Libraries::LibKernel { -thread_local PthreadInternal g_pthread_self{}; +thread_local ScePthread g_pthread_self{}; PThreadCxt* g_pthread_cxt = nullptr; constexpr bool log_pthread_file = true; // disable it to disable logging @@ -21,9 +21,10 @@ void init_pthreads() { } void pthreadInitSelfMainThread() { - scePthreadAttrInit(&g_pthread_self.attr); - g_pthread_self.pth = pthread_self(); - g_pthread_self.name = "Main_Thread"; + g_pthread_self = new PthreadInternal{}; + scePthreadAttrInit(&g_pthread_self->attr); + g_pthread_self->pth = pthread_self(); + g_pthread_self->name = "Main_Thread"; } int PS4_SYSV_ABI scePthreadAttrInit(ScePthreadAttr* attr) { @@ -61,7 +62,8 @@ int PS4_SYSV_ABI scePthreadAttrSetdetachstate(ScePthreadAttr* attr, int detachst default: LOG_TRACE_IF(log_pthread_file, "scePthreadAttrSetdetachstate invalid detachstate: {}\n", detachstate); std::exit(0); } - int result = pthread_attr_setdetachstate(&(*attr)->pth_attr, pstate); + //int result = pthread_attr_setdetachstate(&(*attr)->pth_attr, pstate); doesn't seem to work correctly + int result = 0; (*attr)->detached = (pstate == PTHREAD_CREATE_DETACHED); @@ -119,7 +121,35 @@ int PS4_SYSV_ABI scePthreadAttrSetschedpolicy(ScePthreadAttr* attr, int policy) return result == 0 ? SCE_OK : SCE_KERNEL_ERROR_EINVAL; } +ScePthread PS4_SYSV_ABI scePthreadSelf() { return g_pthread_self; } +int PS4_SYSV_ABI scePthreadAttrSetaffinity(ScePthreadAttr* pattr, const /*SceKernelCpumask*/ u64 mask) { + PRINT_FUNCTION_NAME(); + + if (pattr == nullptr || *pattr == nullptr) { + return SCE_KERNEL_ERROR_EINVAL; + } + + (*pattr)->affinity = mask; + + return SCE_OK; +} + +int PS4_SYSV_ABI scePthreadSetaffinity(ScePthread thread, const /*SceKernelCpumask*/ u64 mask) { + PRINT_FUNCTION_NAME(); + + if (thread == nullptr) { + return SCE_KERNEL_ERROR_ESRCH; + } + + auto result = scePthreadAttrSetaffinity(&thread->attr, mask); + + return result; +} +int PS4_SYSV_ABI scePthreadCreate(ScePthread* thread, const ScePthreadAttr* attr, pthreadEntryFunc start_routine, void* arg, const char* name) { + PRINT_DUMMY_FUNCTION_NAME(); + return 0; +} /**** * Mutex calls */ @@ -276,17 +306,23 @@ int PS4_SYSV_ABI posix_pthread_mutex_unlock(ScePthreadMutex* mutex) { } 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); 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); + LIB_FUNCTION("aI+OeCz8xrQ", "libkernel", 1, "libkernel", 1, 1, scePthreadSelf); + LIB_FUNCTION("3qxgM4ezETA", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrSetaffinity); + LIB_FUNCTION("bt3CTBKmGyI", "libkernel", 1, "libkernel", 1, 1, scePthreadSetaffinity); + LIB_FUNCTION("6UgtwV+0zb4", "libkernel", 1, "libkernel", 1, 1, scePthreadCreate); + //mutex calls + 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); 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); @@ -297,4 +333,4 @@ void pthreadSymbolsRegister(Loader::SymbolsResolver* sym) { LIB_FUNCTION("2Z+PpY6CaJg", "libkernel", 1, "libkernel", 1, 1, posix_pthread_mutex_unlock); } -} // namespace Core::Libraries::LibKernel +} // namespace Core::Libraries::LibKernel \ No newline at end of file diff --git a/src/core/hle/libraries/libkernel/thread_management.h b/src/core/hle/libraries/libkernel/thread_management.h index da68d8a0..44303364 100644 --- a/src/core/hle/libraries/libkernel/thread_management.h +++ b/src/core/hle/libraries/libkernel/thread_management.h @@ -17,12 +17,16 @@ namespace Core::Libraries::LibKernel { struct PthreadAttrInternal; struct PthreadMutexInternal; struct PthreadMutexattrInternal; +struct PthreadInternal; using SceKernelSchedParam = ::sched_param; +using ScePthread = PthreadInternal*; using ScePthreadAttr = PthreadAttrInternal*; using ScePthreadMutex = PthreadMutexInternal*; using ScePthreadMutexattr = PthreadMutexattrInternal*; +using pthreadEntryFunc = PS4_SYSV_ABI void* (*)(void*); + struct PthreadInternal { u08 reserved[4096]; std::string name; @@ -68,6 +72,10 @@ int PS4_SYSV_ABI scePthreadAttrSetdetachstate(ScePthreadAttr* attr, int detachst 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); +ScePthread PS4_SYSV_ABI scePthreadSelf(); +int PS4_SYSV_ABI scePthreadAttrSetaffinity(ScePthreadAttr* pattr, const /*SceKernelCpumask*/ u64 mask); +int PS4_SYSV_ABI scePthreadSetaffinity(ScePthread thread, const /*SceKernelCpumask*/ u64 mask); +int PS4_SYSV_ABI scePthreadCreate(ScePthread* thread, const ScePthreadAttr* attr, pthreadEntryFunc start_routine, void* arg, const char* name); /*** * Mutex calls @@ -86,4 +94,4 @@ 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 +} // namespace Core::Libraries::LibKernel \ No newline at end of file From 776a680e850b0358e87707031cd1b4e2c13d78d0 Mon Sep 17 00:00:00 2001 From: georgemoralis Date: Thu, 16 Nov 2023 09:13:50 +0200 Subject: [PATCH 2/4] prefix in libc functions to avoid messing with std ones --- src/core/hle/libraries/libc/libc.cpp | 112 ++++++++++---------- src/core/hle/libraries/libc/libc_cxa.cpp | 6 +- src/core/hle/libraries/libc/libc_cxa.h | 6 +- src/core/hle/libraries/libc/libc_math.cpp | 16 +-- src/core/hle/libraries/libc/libc_math.h | 16 +-- src/core/hle/libraries/libc/libc_stdio.cpp | 8 +- src/core/hle/libraries/libc/libc_stdio.h | 8 +- src/core/hle/libraries/libc/libc_stdlib.cpp | 12 +-- src/core/hle/libraries/libc/libc_stdlib.h | 12 +-- src/core/hle/libraries/libc/libc_string.cpp | 18 ++-- src/core/hle/libraries/libc/libc_string.h | 18 ++-- 11 files changed, 116 insertions(+), 116 deletions(-) diff --git a/src/core/hle/libraries/libc/libc.cpp b/src/core/hle/libraries/libc/libc.cpp index ff64d485..8d273695 100644 --- a/src/core/hle/libraries/libc/libc.cpp +++ b/src/core/hle/libraries/libc/libc.cpp @@ -27,7 +27,7 @@ struct CContext { std::vector cxa; }; -static PS4_SYSV_ABI int __cxa_atexit(void (*func)(void*), void* arg, void* dso_handle) { +static PS4_SYSV_ABI int ps4___cxa_atexit(void (*func)(void*), void* arg, void* dso_handle) { auto* cc = Common::Singleton::Instance(); CxaDestructor c{}; c.destructor_func = func; @@ -37,42 +37,42 @@ static PS4_SYSV_ABI int __cxa_atexit(void (*func)(void*), void* arg, void* dso_h return 0; } -void PS4_SYSV_ABI __cxa_finalize(void* d) { +void PS4_SYSV_ABI ps4___cxa_finalize(void* d) { BREAKPOINT(); } -void PS4_SYSV_ABI __cxa_pure_virtual() { +void PS4_SYSV_ABI ps4___cxa_pure_virtual() { BREAKPOINT(); } -static PS4_SYSV_ABI void init_env() { +static PS4_SYSV_ABI void ps4_init_env() { PRINT_DUMMY_FUNCTION_NAME(); } -static PS4_SYSV_ABI void catchReturnFromMain(int status) { +static PS4_SYSV_ABI void ps4_catchReturnFromMain(int status) { LOG_INFO_IF(log_file_libc, "catchReturnFromMain returned ={}\n", status); } -static PS4_SYSV_ABI void _Assert() { +static PS4_SYSV_ABI void ps4__Assert() { PRINT_DUMMY_FUNCTION_NAME(); BREAKPOINT(); } -PS4_SYSV_ABI void _ZdlPv(void* ptr) { +PS4_SYSV_ABI void ps4__ZdlPv(void* ptr) { std::free(ptr); } -PS4_SYSV_ABI void _ZSt11_Xbad_allocv() { +PS4_SYSV_ABI void ps4__ZSt11_Xbad_allocv() { PRINT_DUMMY_FUNCTION_NAME(); BREAKPOINT(); } -PS4_SYSV_ABI void _ZSt14_Xlength_errorPKc() { +PS4_SYSV_ABI void ps4__ZSt14_Xlength_errorPKc() { PRINT_DUMMY_FUNCTION_NAME(); BREAKPOINT(); } -PS4_SYSV_ABI void* _Znwm(u64 count) { +PS4_SYSV_ABI void* ps4__Znwm(u64 count) { if (count == 0) { LOG_ERROR_IF(log_file_libc, "_Znwm count ={}\n", count); BREAKPOINT(); @@ -99,7 +99,7 @@ static constexpr u16 lowercaseTable[256] = { 0x00FC, 0x00FD, 0x00FE, 0x00FF, }; -const PS4_SYSV_ABI u16* _Getptolower() { return &lowercaseTable[0]; } +const PS4_SYSV_ABI u16* ps4__Getptolower() { return &lowercaseTable[0]; } static constexpr u16 uppercaseTable[256] = { 0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F, 0x0010, 0x0011, @@ -119,7 +119,7 @@ static constexpr u16 uppercaseTable[256] = { 0x00FC, 0x00FD, 0x00FE, 0x00FF, }; -const PS4_SYSV_ABI u16* _Getptoupper() { return &uppercaseTable[0]; } +const PS4_SYSV_ABI u16* ps4__Getptoupper() { return &uppercaseTable[0]; } namespace CharacterType { enum : u16 { @@ -396,66 +396,66 @@ static constexpr u16 characterTypeTable[256] = { 0, }; -const PS4_SYSV_ABI u16* _Getpctype() { return &characterTypeTable[0]; } +const PS4_SYSV_ABI u16* ps4__Getpctype() { return &characterTypeTable[0]; } void libcSymbolsRegister(Loader::SymbolsResolver* sym) { // cxa functions - LIB_FUNCTION("3GPpjQdAMTw", "libc", 1, "libc", 1, 1, __cxa_guard_acquire); - LIB_FUNCTION("9rAeANT2tyE", "libc", 1, "libc", 1, 1, __cxa_guard_release); - LIB_FUNCTION("2emaaluWzUw", "libc", 1, "libc", 1, 1, __cxa_guard_abort); + LIB_FUNCTION("3GPpjQdAMTw", "libc", 1, "libc", 1, 1, ps4___cxa_guard_acquire); + LIB_FUNCTION("9rAeANT2tyE", "libc", 1, "libc", 1, 1, ps4___cxa_guard_release); + LIB_FUNCTION("2emaaluWzUw", "libc", 1, "libc", 1, 1, ps4___cxa_guard_abort); // stdlib functions - LIB_FUNCTION("uMei1W9uyNo", "libc", 1, "libc", 1, 1, exit); - LIB_FUNCTION("8G2LB+A3rzg", "libc", 1, "libc", 1, 1, atexit); - LIB_FUNCTION("gQX+4GDQjpM", "libc", 1, "libc", 1, 1, malloc); - LIB_FUNCTION("tIhsqj0qsFE", "libc", 1, "libc", 1, 1, free); - LIB_FUNCTION("cpCOXWMgha0", "libc", 1, "libc", 1, 1, rand); - LIB_FUNCTION("AEJdIVZTEmo", "libc", 1, "libc", 1, 1, qsort); + LIB_FUNCTION("uMei1W9uyNo", "libc", 1, "libc", 1, 1, ps4_exit); + LIB_FUNCTION("8G2LB+A3rzg", "libc", 1, "libc", 1, 1, ps4_atexit); + LIB_FUNCTION("gQX+4GDQjpM", "libc", 1, "libc", 1, 1, ps4_malloc); + LIB_FUNCTION("tIhsqj0qsFE", "libc", 1, "libc", 1, 1, ps4_free); + LIB_FUNCTION("cpCOXWMgha0", "libc", 1, "libc", 1, 1, ps4_rand); + LIB_FUNCTION("AEJdIVZTEmo", "libc", 1, "libc", 1, 1, ps4_qsort); // math functions - LIB_FUNCTION("EH-x713A99c", "libc", 1, "libc", 1, 1, atan2f); - LIB_FUNCTION("QI-x0SL8jhw", "libc", 1, "libc", 1, 1, acosf); - LIB_FUNCTION("ZE6RNL+eLbk", "libc", 1, "libc", 1, 1, tanf); - LIB_FUNCTION("GZWjF-YIFFk", "libc", 1, "libc", 1, 1, asinf); - LIB_FUNCTION("9LCjpWyQ5Zc", "libc", 1, "libc", 1, 1, pow); - LIB_FUNCTION("cCXjU72Z0Ow", "libc", 1, "libc", 1, 1, _Sin); - LIB_FUNCTION("ZtjspkJQ+vw", "libc", 1, "libc", 1, 1, _Fsin); - LIB_FUNCTION("dnaeGXbjP6E", "libc", 1, "libc", 1, 1, exp2); + LIB_FUNCTION("EH-x713A99c", "libc", 1, "libc", 1, 1, ps4_atan2f); + LIB_FUNCTION("QI-x0SL8jhw", "libc", 1, "libc", 1, 1, ps4_acosf); + LIB_FUNCTION("ZE6RNL+eLbk", "libc", 1, "libc", 1, 1, ps4_tanf); + LIB_FUNCTION("GZWjF-YIFFk", "libc", 1, "libc", 1, 1, ps4_asinf); + LIB_FUNCTION("9LCjpWyQ5Zc", "libc", 1, "libc", 1, 1, ps4_pow); + LIB_FUNCTION("cCXjU72Z0Ow", "libc", 1, "libc", 1, 1, ps4__Sin); + LIB_FUNCTION("ZtjspkJQ+vw", "libc", 1, "libc", 1, 1, ps4__Fsin); + LIB_FUNCTION("dnaeGXbjP6E", "libc", 1, "libc", 1, 1, ps4_exp2); // string functions - LIB_FUNCTION("Ovb2dSJOAuE", "libc", 1, "libc", 1, 1, strcmp); - LIB_FUNCTION("j4ViWNHEgww", "libc", 1, "libc", 1, 1, strlen); - LIB_FUNCTION("6sJWiWSRuqk", "libc", 1, "libc", 1, 1, strncpy); - LIB_FUNCTION("+P6FRGH4LfA", "libc", 1, "libc", 1, 1, memmove); - LIB_FUNCTION("kiZSXIWd9vg", "libc", 1, "libc", 1, 1, strcpy); - LIB_FUNCTION("Ls4tzzhimqQ", "libc", 1, "libc", 1, 1, strcat); - LIB_FUNCTION("DfivPArhucg", "libc", 1, "libc", 1, 1, memcmp); - LIB_FUNCTION("Q3VBxCXhUHs", "libc", 1, "libc", 1, 1, memcpy); - LIB_FUNCTION("8zTFvBIAIN8", "libc", 1, "libc", 1, 1, memset); + LIB_FUNCTION("Ovb2dSJOAuE", "libc", 1, "libc", 1, 1, ps4_strcmp); + LIB_FUNCTION("j4ViWNHEgww", "libc", 1, "libc", 1, 1, ps4_strlen); + LIB_FUNCTION("6sJWiWSRuqk", "libc", 1, "libc", 1, 1, ps4_strncpy); + LIB_FUNCTION("+P6FRGH4LfA", "libc", 1, "libc", 1, 1, ps4_memmove); + LIB_FUNCTION("kiZSXIWd9vg", "libc", 1, "libc", 1, 1, ps4_strcpy); + LIB_FUNCTION("Ls4tzzhimqQ", "libc", 1, "libc", 1, 1, ps4_strcat); + LIB_FUNCTION("DfivPArhucg", "libc", 1, "libc", 1, 1, ps4_memcmp); + LIB_FUNCTION("Q3VBxCXhUHs", "libc", 1, "libc", 1, 1, ps4_memcpy); + LIB_FUNCTION("8zTFvBIAIN8", "libc", 1, "libc", 1, 1, ps4_memset); // stdio functions - LIB_FUNCTION("hcuQgD53UxM", "libc", 1, "libc", 1, 1, printf); - LIB_FUNCTION("Q2V+iqvjgC0", "libc", 1, "libc", 1, 1, vsnprintf); - LIB_FUNCTION("YQ0navp+YIc", "libc", 1, "libc", 1, 1, puts); - LIB_FUNCTION("fffwELXNVFA", "libc", 1, "libc", 1, 1, fprintf); + LIB_FUNCTION("hcuQgD53UxM", "libc", 1, "libc", 1, 1, ps4_printf); + LIB_FUNCTION("Q2V+iqvjgC0", "libc", 1, "libc", 1, 1, ps4_vsnprintf); + LIB_FUNCTION("YQ0navp+YIc", "libc", 1, "libc", 1, 1, ps4_puts); + LIB_FUNCTION("fffwELXNVFA", "libc", 1, "libc", 1, 1, ps4_fprintf); // misc LIB_OBJ("P330P3dFF68", "libc", 1, "libc", 1, 1, &g_need_sceLibc); LIB_OBJ("2sWzhYqFH4E","libc", 1, "libc", 1, 1,stdout); LIB_OBJ("H8AprKeZtNg", "libc", 1, "libc", 1, 1, stderr); - LIB_FUNCTION("bzQExy189ZI", "libc", 1, "libc", 1, 1, init_env); - LIB_FUNCTION("XKRegsFpEpk", "libc", 1, "libc", 1, 1, catchReturnFromMain); - LIB_FUNCTION("-QgqOT5u2Vk", "libc", 1, "libc", 1, 1, _Assert); - LIB_FUNCTION("z+P+xCnWLBk", "libc", 1, "libc", 1, 1, _ZdlPv); - LIB_FUNCTION("eT2UsmTewbU", "libc", 1, "libc", 1, 1, _ZSt11_Xbad_allocv); - LIB_FUNCTION("tQIo+GIPklo", "libc", 1, "libc", 1, 1, _ZSt14_Xlength_errorPKc); - LIB_FUNCTION("fJnpuVVBbKk", "libc", 1, "libc", 1, 1, _Znwm); - LIB_FUNCTION("tsvEmnenz48", "libc", 1, "libc", 1, 1, __cxa_atexit); - LIB_FUNCTION("H2e8t5ScQGc", "libc", 1, "libc", 1, 1, __cxa_finalize); - LIB_FUNCTION("zr094EQ39Ww", "libc", 1, "libc", 1, 1, __cxa_pure_virtual); - LIB_FUNCTION("1uJgoVq3bQU", "libc", 1, "libc", 1, 1, _Getptolower); - LIB_FUNCTION("rcQCUr0EaRU", "libc", 1, "libc", 1, 1, _Getptoupper); - LIB_FUNCTION("sUP1hBaouOw", "libc", 1, "libc", 1, 1, _Getpctype); + LIB_FUNCTION("bzQExy189ZI", "libc", 1, "libc", 1, 1, ps4_init_env); + LIB_FUNCTION("XKRegsFpEpk", "libc", 1, "libc", 1, 1, ps4_catchReturnFromMain); + LIB_FUNCTION("-QgqOT5u2Vk", "libc", 1, "libc", 1, 1, ps4__Assert); + LIB_FUNCTION("z+P+xCnWLBk", "libc", 1, "libc", 1, 1, ps4__ZdlPv); + LIB_FUNCTION("eT2UsmTewbU", "libc", 1, "libc", 1, 1, ps4__ZSt11_Xbad_allocv); + LIB_FUNCTION("tQIo+GIPklo", "libc", 1, "libc", 1, 1, ps4__ZSt14_Xlength_errorPKc); + LIB_FUNCTION("fJnpuVVBbKk", "libc", 1, "libc", 1, 1, ps4__Znwm); + LIB_FUNCTION("tsvEmnenz48", "libc", 1, "libc", 1, 1, ps4___cxa_atexit); + LIB_FUNCTION("H2e8t5ScQGc", "libc", 1, "libc", 1, 1, ps4___cxa_finalize); + LIB_FUNCTION("zr094EQ39Ww", "libc", 1, "libc", 1, 1, ps4___cxa_pure_virtual); + LIB_FUNCTION("1uJgoVq3bQU", "libc", 1, "libc", 1, 1, ps4__Getptolower); + LIB_FUNCTION("rcQCUr0EaRU", "libc", 1, "libc", 1, 1, ps4__Getptoupper); + LIB_FUNCTION("sUP1hBaouOw", "libc", 1, "libc", 1, 1, ps4__Getpctype); } }; // namespace Core::Libraries::LibC diff --git a/src/core/hle/libraries/libc/libc_cxa.cpp b/src/core/hle/libraries/libc/libc_cxa.cpp index 4c8abd14..2b27b648 100644 --- a/src/core/hle/libraries/libc/libc_cxa.cpp +++ b/src/core/hle/libraries/libc/libc_cxa.cpp @@ -73,7 +73,7 @@ static void setNotInUse(u64* guard_object) { ((u08*)guard_object)[1] = 0; } // aborts if called again on the same guard object without an intervening // call to __cxa_guard_release() or __cxa_guard_abort(). // -int PS4_SYSV_ABI __cxa_guard_acquire(u64* guard_object) { +int PS4_SYSV_ABI ps4___cxa_guard_acquire(u64* guard_object) { // Double check that the initializer has not already been run if (initializerHasRun(guard_object)) return 0; @@ -121,7 +121,7 @@ int PS4_SYSV_ABI __cxa_guard_acquire(u64* guard_object) { // Sets the first byte of the guard_object to a non-zero value. // Releases any locks acquired by __cxa_guard_acquire(). // -void PS4_SYSV_ABI __cxa_guard_release(u64* guard_object) { +void PS4_SYSV_ABI ps4___cxa_guard_release(u64* guard_object) { // first mark initalizer as having been run, so // other threads won't try to re-run it. setInitializerHasRun(guard_object); @@ -136,7 +136,7 @@ void PS4_SYSV_ABI __cxa_guard_release(u64* guard_object) { // // Releases any locks acquired by __cxa_guard_acquire(). // -void PS4_SYSV_ABI __cxa_guard_abort(u64* guard_object) { +void PS4_SYSV_ABI ps4___cxa_guard_abort(u64* guard_object) { int result = ::pthread_mutex_unlock(guard_mutex()); if (result != 0) { LOG_TRACE_IF(log_file_cxa, "__cxa_guard_abort(): pthread_mutex_unlock failed with {}\n", result); diff --git a/src/core/hle/libraries/libc/libc_cxa.h b/src/core/hle/libraries/libc/libc_cxa.h index 7818b243..ad761562 100644 --- a/src/core/hle/libraries/libc/libc_cxa.h +++ b/src/core/hle/libraries/libc/libc_cxa.h @@ -6,8 +6,8 @@ namespace Core::Libraries::LibC { -int PS4_SYSV_ABI __cxa_guard_acquire(u64* guard_object); -void PS4_SYSV_ABI __cxa_guard_release(u64* guard_object); -void PS4_SYSV_ABI __cxa_guard_abort(u64* guard_object); +int PS4_SYSV_ABI ps4___cxa_guard_acquire(u64* guard_object); +void PS4_SYSV_ABI ps4___cxa_guard_release(u64* guard_object); +void PS4_SYSV_ABI ps4___cxa_guard_abort(u64* guard_object); } // namespace Core::Libraries::LibC diff --git a/src/core/hle/libraries/libc/libc_math.cpp b/src/core/hle/libraries/libc/libc_math.cpp index 7a18b8e1..541dfb1a 100644 --- a/src/core/hle/libraries/libc/libc_math.cpp +++ b/src/core/hle/libraries/libc/libc_math.cpp @@ -3,35 +3,35 @@ namespace Core::Libraries::LibC { -float PS4_SYSV_ABI atan2f(float y, float x) { +float PS4_SYSV_ABI ps4_atan2f(float y, float x) { return std::atan2f(y, x); } -float PS4_SYSV_ABI acosf(float num) { +float PS4_SYSV_ABI ps4_acosf(float num) { return std::acosf(num); } -float PS4_SYSV_ABI tanf(float num) { +float PS4_SYSV_ABI ps4_tanf(float num) { return std::tanf(num); } -float PS4_SYSV_ABI asinf(float num) { +float PS4_SYSV_ABI ps4_asinf(float num) { return std::asinf(num); } -double PS4_SYSV_ABI pow(double base, double exponent) { +double PS4_SYSV_ABI ps4_pow(double base, double exponent) { return std::pow(base, exponent); } -double PS4_SYSV_ABI _Sin(double x) { +double PS4_SYSV_ABI ps4__Sin(double x) { return std::sin(x); } -float PS4_SYSV_ABI _Fsin(float arg) { +float PS4_SYSV_ABI ps4__Fsin(float arg) { return std::sinf(arg); } -double PS4_SYSV_ABI exp2(double arg) { +double PS4_SYSV_ABI ps4_exp2(double arg) { return std::exp2(arg); } diff --git a/src/core/hle/libraries/libc/libc_math.h b/src/core/hle/libraries/libc/libc_math.h index 53a51fd4..fcc6448c 100644 --- a/src/core/hle/libraries/libc/libc_math.h +++ b/src/core/hle/libraries/libc/libc_math.h @@ -4,13 +4,13 @@ namespace Core::Libraries::LibC { -float PS4_SYSV_ABI atan2f(float y, float x); -float PS4_SYSV_ABI acosf(float num); -float PS4_SYSV_ABI tanf(float num); -float PS4_SYSV_ABI asinf(float num); -double PS4_SYSV_ABI pow(double base, double exponent); -double PS4_SYSV_ABI _Sin(double x); -float PS4_SYSV_ABI _Fsin(float arg); -double PS4_SYSV_ABI exp2(double arg); +float PS4_SYSV_ABI ps4_atan2f(float y, float x); +float PS4_SYSV_ABI ps4_acosf(float num); +float PS4_SYSV_ABI ps4_tanf(float num); +float PS4_SYSV_ABI ps4_asinf(float num); +double PS4_SYSV_ABI ps4_pow(double base, double exponent); +double PS4_SYSV_ABI ps4__Sin(double x); +float PS4_SYSV_ABI ps4__Fsin(float arg); +double PS4_SYSV_ABI ps4_exp2(double arg); } // namespace Core::Libraries::LibC diff --git a/src/core/hle/libraries/libc/libc_stdio.cpp b/src/core/hle/libraries/libc/libc_stdio.cpp index 52e0c26a..b3b5dac2 100644 --- a/src/core/hle/libraries/libc/libc_stdio.cpp +++ b/src/core/hle/libraries/libc/libc_stdio.cpp @@ -6,12 +6,12 @@ namespace Core::Libraries::LibC { constexpr bool log_file_libc = true; // disable it to disable logging -int PS4_SYSV_ABI printf(VA_ARGS) { +int PS4_SYSV_ABI ps4_printf(VA_ARGS) { VA_CTX(ctx); return printf_ctx(&ctx); } -int PS4_SYSV_ABI fprintf(FILE* file, VA_ARGS) { +int PS4_SYSV_ABI ps4_fprintf(FILE* file, VA_ARGS) { int fd = _fileno(file); if (fd == 1 || fd == 2) { // output stdout and stderr to console VA_CTX(ctx); @@ -22,11 +22,11 @@ int PS4_SYSV_ABI fprintf(FILE* file, VA_ARGS) { return 0; } -int PS4_SYSV_ABI vsnprintf(char* s, size_t n, const char* format, VaList* arg) { +int PS4_SYSV_ABI ps4_vsnprintf(char* s, size_t n, const char* format, VaList* arg) { return vsnprintf_ctx(s, n, format, arg); } -int PS4_SYSV_ABI puts(const char* s) { +int PS4_SYSV_ABI ps4_puts(const char* s) { return std::puts(s); } diff --git a/src/core/hle/libraries/libc/libc_stdio.h b/src/core/hle/libraries/libc/libc_stdio.h index 20ffbc21..2992d07f 100644 --- a/src/core/hle/libraries/libc/libc_stdio.h +++ b/src/core/hle/libraries/libc/libc_stdio.h @@ -5,9 +5,9 @@ namespace Core::Libraries::LibC { -int PS4_SYSV_ABI printf(VA_ARGS); -int PS4_SYSV_ABI vsnprintf(char* s, size_t n, const char* format, VaList* arg); -int PS4_SYSV_ABI puts(const char* s); -int PS4_SYSV_ABI fprintf(FILE* file, VA_ARGS); +int PS4_SYSV_ABI ps4_printf(VA_ARGS); +int PS4_SYSV_ABI ps4_vsnprintf(char* s, size_t n, const char* format, VaList* arg); +int PS4_SYSV_ABI ps4_puts(const char* s); +int PS4_SYSV_ABI ps4_fprintf(FILE* file, VA_ARGS); } // namespace Core::Libraries::LibC diff --git a/src/core/hle/libraries/libc/libc_stdlib.cpp b/src/core/hle/libraries/libc/libc_stdlib.cpp index d5c32d56..87fe74e3 100644 --- a/src/core/hle/libraries/libc/libc_stdlib.cpp +++ b/src/core/hle/libraries/libc/libc_stdlib.cpp @@ -7,11 +7,11 @@ namespace Core::Libraries::LibC { constexpr bool log_file_libc = true; // disable it to disable logging -void PS4_SYSV_ABI exit(int code) { +void PS4_SYSV_ABI ps4_exit(int code) { std::exit(code); } -int PS4_SYSV_ABI atexit(void (*func)()) { +int PS4_SYSV_ABI ps4_atexit(void (*func)()) { int rt = std::atexit(func); if (rt != 0) { LOG_ERROR_IF(log_file_libc, "atexit returned {}\n", rt); @@ -20,11 +20,11 @@ int PS4_SYSV_ABI atexit(void (*func)()) { return rt; } -void* PS4_SYSV_ABI malloc(size_t size) { +void* PS4_SYSV_ABI ps4_malloc(size_t size) { return std::malloc(size); } -void PS4_SYSV_ABI free(void* ptr) { +void PS4_SYSV_ABI ps4_free(void* ptr) { std::free(ptr); } @@ -35,12 +35,12 @@ int qsort_compair(const void* arg1, const void* arg2) { return compair_ps4(arg1, arg2); } -void PS4_SYSV_ABI qsort(void* ptr, size_t count, size_t size, int(PS4_SYSV_ABI* comp)(const void*, const void*)) { +void PS4_SYSV_ABI ps4_qsort(void* ptr, size_t count, size_t size, int(PS4_SYSV_ABI* comp)(const void*, const void*)) { compair_ps4 = comp; std::qsort(ptr, count, size, qsort_compair); } -int PS4_SYSV_ABI rand() { +int PS4_SYSV_ABI ps4_rand() { return std::rand(); } diff --git a/src/core/hle/libraries/libc/libc_stdlib.h b/src/core/hle/libraries/libc/libc_stdlib.h index 5704d648..bd8f7e67 100644 --- a/src/core/hle/libraries/libc/libc_stdlib.h +++ b/src/core/hle/libraries/libc/libc_stdlib.h @@ -5,11 +5,11 @@ namespace Core::Libraries::LibC { -void PS4_SYSV_ABI exit(int code); -int PS4_SYSV_ABI atexit(void (*func)()); -void* PS4_SYSV_ABI malloc(size_t size); -void PS4_SYSV_ABI free(void* ptr); -void PS4_SYSV_ABI qsort(void* ptr, size_t count, size_t size, int(PS4_SYSV_ABI* comp)(const void*, const void*)); -int PS4_SYSV_ABI rand(); +void PS4_SYSV_ABI ps4_exit(int code); +int PS4_SYSV_ABI ps4_atexit(void (*func)()); +void* PS4_SYSV_ABI ps4_malloc(size_t size); +void PS4_SYSV_ABI ps4_free(void* ptr); +void PS4_SYSV_ABI ps4_qsort(void* ptr, size_t count, size_t size, int(PS4_SYSV_ABI* comp)(const void*, const void*)); +int PS4_SYSV_ABI ps4_rand(); } // namespace Core::Libraries::LibC diff --git a/src/core/hle/libraries/libc/libc_string.cpp b/src/core/hle/libraries/libc/libc_string.cpp index 3effa7bf..609a8670 100644 --- a/src/core/hle/libraries/libc/libc_string.cpp +++ b/src/core/hle/libraries/libc/libc_string.cpp @@ -3,39 +3,39 @@ namespace Core::Libraries::LibC { -int PS4_SYSV_ABI memcmp(const void* s1, const void* s2, size_t n) { +int PS4_SYSV_ABI ps4_memcmp(const void* s1, const void* s2, size_t n) { return std::memcmp(s1, s2, n); } -void* PS4_SYSV_ABI memcpy(void* dest, const void* src, size_t n) { +void* PS4_SYSV_ABI ps4_memcpy(void* dest, const void* src, size_t n) { return std::memcpy(dest, src, n); } -void* PS4_SYSV_ABI memset(void* s, int c, size_t n) { +void* PS4_SYSV_ABI ps4_memset(void* s, int c, size_t n) { return std::memset(s, c, n); } -int PS4_SYSV_ABI strcmp(const char* str1, const char* str2) { +int PS4_SYSV_ABI ps4_strcmp(const char* str1, const char* str2) { return std::strcmp(str1, str2); } -char* PS4_SYSV_ABI strncpy(char* dest, const char* src, size_t count) { +char* PS4_SYSV_ABI ps4_strncpy(char* dest, const char* src, size_t count) { return std::strncpy(dest, src, count); } -void* PS4_SYSV_ABI memmove(void* dest, const void* src, std::size_t count) { +void* PS4_SYSV_ABI ps4_memmove(void* dest, const void* src, std::size_t count) { return std::memmove(dest, src, count); } -char* PS4_SYSV_ABI strcpy(char* dest, const char* src) { +char* PS4_SYSV_ABI ps4_strcpy(char* dest, const char* src) { return std::strcpy(dest, src); } -char* PS4_SYSV_ABI strcat(char* dest, const char* src) { +char* PS4_SYSV_ABI ps4_strcat(char* dest, const char* src) { return std::strcat(dest, src); } -size_t PS4_SYSV_ABI strlen(const char* str) { +size_t PS4_SYSV_ABI ps4_strlen(const char* str) { return std::strlen(str); } diff --git a/src/core/hle/libraries/libc/libc_string.h b/src/core/hle/libraries/libc/libc_string.h index b5c29e23..30209aec 100644 --- a/src/core/hle/libraries/libc/libc_string.h +++ b/src/core/hle/libraries/libc/libc_string.h @@ -5,14 +5,14 @@ namespace Core::Libraries::LibC { -int PS4_SYSV_ABI memcmp(const void* s1, const void* s2, size_t n); -void* PS4_SYSV_ABI memcpy(void* dest, const void* src, size_t n); -void* PS4_SYSV_ABI memset(void* s, int c, size_t n); -int PS4_SYSV_ABI strcmp(const char* str1, const char* str2); -char* PS4_SYSV_ABI strncpy(char* dest, const char* src, size_t count); -void* PS4_SYSV_ABI memmove(void* dest, const void* src, std::size_t count); -char* PS4_SYSV_ABI strcpy(char* destination, const char* source); -char* PS4_SYSV_ABI strcat(char* dest, const char* src); -size_t PS4_SYSV_ABI strlen(const char* str); +int PS4_SYSV_ABI ps4_memcmp(const void* s1, const void* s2, size_t n); +void* PS4_SYSV_ABI ps4_memcpy(void* dest, const void* src, size_t n); +void* PS4_SYSV_ABI ps4_memset(void* s, int c, size_t n); +int PS4_SYSV_ABI ps4_strcmp(const char* str1, const char* str2); +char* PS4_SYSV_ABI ps4_strncpy(char* dest, const char* src, size_t count); +void* PS4_SYSV_ABI ps4_memmove(void* dest, const void* src, std::size_t count); +char* PS4_SYSV_ABI ps4_strcpy(char* destination, const char* source); +char* PS4_SYSV_ABI ps4_strcat(char* dest, const char* src); +size_t PS4_SYSV_ABI ps4_strlen(const char* str); } // namespace Core::Libraries::LibC From 1316443c59fcf27ae4b0f85caed12c58d4d93309 Mon Sep 17 00:00:00 2001 From: georgemoralis Date: Thu, 16 Nov 2023 09:14:10 +0200 Subject: [PATCH 3/4] initial ScePthreadCond works --- .../libraries/libkernel/thread_management.h | 20 ++++++++++++++++++- 1 file changed, 19 insertions(+), 1 deletion(-) diff --git a/src/core/hle/libraries/libkernel/thread_management.h b/src/core/hle/libraries/libkernel/thread_management.h index 44303364..74f8d7b9 100644 --- a/src/core/hle/libraries/libkernel/thread_management.h +++ b/src/core/hle/libraries/libkernel/thread_management.h @@ -14,16 +14,20 @@ class SymbolsResolver; namespace Core::Libraries::LibKernel { +struct PthreadInternal; struct PthreadAttrInternal; struct PthreadMutexInternal; struct PthreadMutexattrInternal; -struct PthreadInternal; +struct PthreadCondInternal; +struct PthreadCondAttrInternal; using SceKernelSchedParam = ::sched_param; using ScePthread = PthreadInternal*; using ScePthreadAttr = PthreadAttrInternal*; using ScePthreadMutex = PthreadMutexInternal*; using ScePthreadMutexattr = PthreadMutexattrInternal*; +using ScePthreadCond = PthreadCondInternal*; +using ScePthreadCondattr = PthreadCondAttrInternal*; using pthreadEntryFunc = PS4_SYSV_ABI void* (*)(void*); @@ -55,13 +59,27 @@ struct PthreadMutexattrInternal { int pprotocol; }; +struct PthreadCondInternal { + u08 reserved[256]; + std::string name; + pthread_cond_t cond; +}; + +struct PthreadCondAttrInternal { + u08 reserved[64]; + pthread_condattr_t cond_attr; +}; + class PThreadCxt { public: ScePthreadMutexattr* getDefaultMutexattr() { return &m_default_mutexattr; } void setDefaultMutexattr(ScePthreadMutexattr attr) { m_default_mutexattr = attr; } + ScePthreadCondattr* getDefaultCondattr() { return &m_default_condattr; } + void setDefaultCondattr(ScePthreadCondattr attr) { m_default_condattr = attr; } private: ScePthreadMutexattr m_default_mutexattr = nullptr; + ScePthreadCondattr m_default_condattr = nullptr; }; void init_pthreads(); From 3e8cd57986d8d830fbc88f9b7148fc34644d24de Mon Sep 17 00:00:00 2001 From: georgemoralis Date: Thu, 16 Nov 2023 13:31:12 +0200 Subject: [PATCH 4/4] scePthreadCond functions --- .../libraries/libkernel/thread_management.cpp | 103 +++++++++++++++++- .../libraries/libkernel/thread_management.h | 7 ++ 2 files changed, 106 insertions(+), 4 deletions(-) diff --git a/src/core/hle/libraries/libkernel/thread_management.cpp b/src/core/hle/libraries/libkernel/thread_management.cpp index 0e982e0b..6d82be94 100644 --- a/src/core/hle/libraries/libkernel/thread_management.cpp +++ b/src/core/hle/libraries/libkernel/thread_management.cpp @@ -15,9 +15,14 @@ constexpr bool log_pthread_file = true; // disable it to disable logging void init_pthreads() { g_pthread_cxt = new PThreadCxt{}; + // default mutex init ScePthreadMutexattr default_mutexattr = nullptr; scePthreadMutexattrInit(&default_mutexattr); g_pthread_cxt->setDefaultMutexattr(default_mutexattr); + // default cond init + ScePthreadCondattr default_condattr = nullptr; + scePthreadCondattrInit(&default_condattr); + g_pthread_cxt->setDefaultCondattr(default_condattr); } void pthreadInitSelfMainThread() { @@ -62,7 +67,7 @@ int PS4_SYSV_ABI scePthreadAttrSetdetachstate(ScePthreadAttr* attr, int detachst default: LOG_TRACE_IF(log_pthread_file, "scePthreadAttrSetdetachstate invalid detachstate: {}\n", detachstate); std::exit(0); } - //int result = pthread_attr_setdetachstate(&(*attr)->pth_attr, pstate); doesn't seem to work correctly + // int result = pthread_attr_setdetachstate(&(*attr)->pth_attr, pstate); doesn't seem to work correctly int result = 0; (*attr)->detached = (pstate == PTHREAD_CREATE_DETACHED); @@ -177,7 +182,7 @@ int PS4_SYSV_ABI scePthreadMutexInit(ScePthreadMutex* mutex, const ScePthreadMut if (name != nullptr) { (*mutex)->name = name; } else { - (*mutex)->name = "noname"; + (*mutex)->name = "nonameMutex"; } int result = pthread_mutex_init(&(*mutex)->pth_mutex, &(*attr)->pth_mutex_attr); @@ -275,6 +280,81 @@ int PS4_SYSV_ABI scePthreadMutexUnlock(ScePthreadMutex* mutex) { } } +/**** + * Cond calls + */ +void* createCond(void* addr) { + if (addr == nullptr || *static_cast(addr) != nullptr) { + return addr; + } + auto vaddr = reinterpret_cast(addr); + + std::string name = fmt::format("cond{:#x}", vaddr); + scePthreadCondInit(static_cast(addr), nullptr, name.c_str()); + return addr; +} + +int PS4_SYSV_ABI scePthreadCondInit(ScePthreadCond* cond, const ScePthreadCondattr* attr, const char* name) { + if (cond == nullptr) { + return SCE_KERNEL_ERROR_EINVAL; + } + + if (attr == nullptr) { + attr = g_pthread_cxt->getDefaultCondattr(); + } + + *cond = new PthreadCondInternal{}; + + if (name != nullptr) { + (*cond)->name = name; + } else { + (*cond)->name = "nonameCond"; + } + + int result = pthread_cond_init(&(*cond)->cond, &(*attr)->cond_attr); + + if (name != nullptr) { + LOG_INFO_IF(log_pthread_file, "cond init name={},result={}\n", (*cond)->name, result); + } + + 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 scePthreadCondattrInit(ScePthreadCondattr* attr) { + *attr = new PthreadCondAttrInternal{}; + + int result = pthread_condattr_init(&(*attr)->cond_attr); + + switch (result) { + case 0: return SCE_OK; + case ENOMEM: return SCE_KERNEL_ERROR_ENOMEM; + default: return SCE_KERNEL_ERROR_EINVAL; + } +} + +int PS4_SYSV_ABI scePthreadCondBroadcast(ScePthreadCond* cond) { + PRINT_FUNCTION_NAME(); + cond = static_cast(createCond(cond)); + + if (cond == nullptr) { + return SCE_KERNEL_ERROR_EINVAL; + } + + int result = pthread_cond_broadcast(&(*cond)->cond); + + LOG_INFO_IF(log_pthread_file, "cond broadcast name={},result={}\n", (*cond)->name, result); + + return (result == 0 ? SCE_OK : SCE_KERNEL_ERROR_EINVAL); +} +/**** + * Posix calls + */ 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); @@ -305,6 +385,16 @@ int PS4_SYSV_ABI posix_pthread_mutex_unlock(ScePthreadMutex* mutex) { return result; } +int PS4_SYSV_ABI posix_pthread_cond_broadcast(ScePthreadCond* cond) { + LOG_INFO_IF(log_pthread_file, "posix posix_pthread_cond_broadcast redirect to scePthreadCondBroadcast\n"); + int result = scePthreadCondBroadcast(cond); + 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(Loader::SymbolsResolver* sym) { LIB_FUNCTION("4+h9EzwKF4I", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrSetschedpolicy); LIB_FUNCTION("-Wreprtu0Qs", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrSetdetachstate); @@ -315,22 +405,27 @@ void pthreadSymbolsRegister(Loader::SymbolsResolver* sym) { LIB_FUNCTION("3qxgM4ezETA", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrSetaffinity); LIB_FUNCTION("bt3CTBKmGyI", "libkernel", 1, "libkernel", 1, 1, scePthreadSetaffinity); LIB_FUNCTION("6UgtwV+0zb4", "libkernel", 1, "libkernel", 1, 1, scePthreadCreate); - //mutex calls + // mutex calls 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); LIB_FUNCTION("9UK1vLZQft4", "libkernel", 1, "libkernel", 1, 1, scePthreadMutexLock); LIB_FUNCTION("tn3VlD0hG60", "libkernel", 1, "libkernel", 1, 1, scePthreadMutexUnlock); - + //cond calls + LIB_FUNCTION("2Tb92quprl0", "libkernel", 1, "libkernel", 1, 1, scePthreadCondInit); + LIB_FUNCTION("m5-2bsNfv7s", "libkernel", 1, "libkernel", 1, 1, scePthreadCondattrInit); + LIB_FUNCTION("JGgj7Uvrl+A", "libkernel", 1, "libkernel", 1, 1, scePthreadCondBroadcast); // 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); + LIB_FUNCTION("mkx2fVhNMsg", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_cond_broadcast); // 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); + LIB_FUNCTION("mkx2fVhNMsg", "libkernel", 1, "libkernel", 1, 1, posix_pthread_cond_broadcast); } } // namespace Core::Libraries::LibKernel \ No newline at end of file diff --git a/src/core/hle/libraries/libkernel/thread_management.h b/src/core/hle/libraries/libkernel/thread_management.h index 74f8d7b9..dc8e9d79 100644 --- a/src/core/hle/libraries/libkernel/thread_management.h +++ b/src/core/hle/libraries/libkernel/thread_management.h @@ -105,11 +105,18 @@ int PS4_SYSV_ABI scePthreadMutexattrSetprotocol(ScePthreadMutexattr* attr, int p int PS4_SYSV_ABI scePthreadMutexLock(ScePthreadMutex* mutex); int PS4_SYSV_ABI scePthreadMutexUnlock(ScePthreadMutex* mutex); /**** + * Cond calls + */ +int PS4_SYSV_ABI scePthreadCondInit(ScePthreadCond* cond, const ScePthreadCondattr* attr, const char* name); +int PS4_SYSV_ABI scePthreadCondattrInit(ScePthreadCondattr* attr); +int PS4_SYSV_ABI scePthreadCondBroadcast(ScePthreadCond* cond); + /**** * 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); +int PS4_SYSV_ABI posix_pthread_cond_broadcast(ScePthreadCond* cond); void pthreadSymbolsRegister(Loader::SymbolsResolver* sym); } // namespace Core::Libraries::LibKernel \ No newline at end of file