Reverting Unity pt1 (causes crashes)

Author: diegolix29

src/common/ntapi.cpp

@@ -5,24 +5,18 @@
 
 #include "ntapi.h"
 
-NtClose_t NtClose = nullptr;
+NtDelayExecution_t NtDelayExecution = nullptr;
 NtSetInformationFile_t NtSetInformationFile = nullptr;
-NtCreateThread_t NtCreateThread = nullptr;
-NtTerminateThread_t NtTerminateThread = nullptr;
-NtQueueApcThreadEx_t NtQueueApcThreadEx = nullptr;
 
 namespace Common::NtApi {
 
 void Initialize() {
     HMODULE nt_handle = GetModuleHandleA("ntdll.dll");
 
     // http://stackoverflow.com/a/31411628/4725495
-    NtClose = (NtClose_t)GetProcAddress(nt_handle, "NtClose");
+    NtDelayExecution = (NtDelayExecution_t)GetProcAddress(nt_handle, "NtDelayExecution");
     NtSetInformationFile =
         (NtSetInformationFile_t)GetProcAddress(nt_handle, "NtSetInformationFile");
-    NtCreateThread = (NtCreateThread_t)GetProcAddress(nt_handle, "NtCreateThread");
-    NtTerminateThread = (NtTerminateThread_t)GetProcAddress(nt_handle, "NtTerminateThread");
-    NtQueueApcThreadEx = (NtQueueApcThreadEx_t)GetProcAddress(nt_handle, "NtQueueApcThreadEx");
 }
 
 } // namespace Common::NtApi

src/common/ntapi.h

@@ -206,7 +206,6 @@ static void RunThread(void* arg) {
     DebugState.AddCurrentThreadToGuestList();
 
     /* Run the current thread's start routine with argument: */
-    curthread->native_thr.Initialize();
     void* ret = Core::ExecuteGuest(curthread->start_routine, curthread->arg);
 
     /* Remove thread from tracking */
@@ -281,7 +280,7 @@ int PS4_SYSV_ABI posix_pthread_create_name_np(PthreadT* thread, const PthreadAtt
     (*thread) = new_thread;
 
     /* Create thread */
-    new_thread->native_thr = Core::NativeThread();
+    new_thread->native_thr = Core::Thread();
     int ret = new_thread->native_thr.Create(RunThread, new_thread, &new_thread->attr);
     ASSERT_MSG(ret == 0, "Failed to create thread with error {}", ret);
     if (ret) {
@@ -414,33 +413,6 @@ int PS4_SYSV_ABI posix_pthread_getschedparam(PthreadT pthread, SchedPolicy* poli
     return 0;
 }
 
-int PS4_SYSV_ABI posix_pthread_setschedparam(PthreadT pthread, SchedPolicy policy,
-                                             const SchedParam* param) {
-    if (pthread == nullptr || param == nullptr) {
-        return POSIX_EINVAL;
-    }
-
-    auto* thread_state = ThrState::Instance();
-    if (pthread == g_curthread) {
-        g_curthread->lock.lock();
-    } else if (int ret = thread_state->FindThread(pthread, /*include dead*/ 0); ret != 0) {
-        return ret;
-    }
-
-    if (pthread->attr.sched_policy == policy &&
-        (policy == SchedPolicy::Other || pthread->attr.prio == param->sched_priority)) {
-        pthread->attr.prio = param->sched_priority;
-        pthread->lock.unlock();
-        return 0;
-    }
-
-    // TODO: _thr_setscheduler
-    pthread->attr.sched_policy = policy;
-    pthread->attr.prio = param->sched_priority;
-    pthread->lock.unlock();
-    return 0;
-}
-
 int PS4_SYSV_ABI scePthreadGetprio(PthreadT thread, int* priority) {
     SchedParam param;
     SchedPolicy policy;
@@ -524,7 +496,6 @@ void RegisterThread(Core::Loader::SymbolsResolver* sym) {
     LIB_FUNCTION("lZzFeSxPl08", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_setcancelstate);
     LIB_FUNCTION("a2P9wYGeZvc", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_setprio);
     LIB_FUNCTION("FIs3-UQT9sg", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_getschedparam);
-    LIB_FUNCTION("Xs9hdiD7sAA", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_setschedparam);
     LIB_FUNCTION("6XG4B33N09g", "libScePosix", 1, "libkernel", 1, 1, sched_yield);
 
     // Posix-Kernel

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

@@ -261,7 +261,7 @@ struct Pthread {
     int refcount;
     PthreadEntryFunc start_routine;
     void* arg;
-    Core::NativeThread native_thr;
+    Core::Thread native_thr;
     PthreadAttr attr;
     bool cancel_enable;
     bool cancel_pending;

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

@@ -328,7 +328,7 @@ int MemoryManager::MapFile(void** out_addr, VAddr virtual_addr, size_t size, Mem
     }
 
     // Map the file.
-    impl.MapFile(mapped_addr, size_aligned, offset, std::bit_cast<u32>(prot), fd);
+    impl.MapFile(mapped_addr, size, offset, std::bit_cast<u32>(prot), fd);
 
     // Add virtual memory area
     auto& new_vma = CarveVMA(mapped_addr, size_aligned)->second;
@@ -514,8 +514,9 @@ int MemoryManager::VirtualQuery(VAddr addr, int flags,
     info->is_flexible.Assign(vma.type == VMAType::Flexible);
     info->is_direct.Assign(vma.type == VMAType::Direct);
     info->is_stack.Assign(vma.type == VMAType::Stack);
-    info->is_pooled.Assign(vma.type == VMAType::PoolReserved);
-    info->is_committed.Assign(vma.type == VMAType::Pooled);
+    info->is_pooled.Assign(vma.type == VMAType::Pooled);
+    info->is_committed.Assign(vma.type != VMAType::Free && vma.type != VMAType::Reserved &&
+                              vma.type != VMAType::PoolReserved);
     vma.name.copy(info->name.data(), std::min(info->name.size(), vma.name.size()));
     if (vma.type == VMAType::Direct) {
         const auto dmem_it = FindDmemArea(vma.phys_base);
@@ -586,7 +587,6 @@ void MemoryManager::NameVirtualRange(VAddr virtual_addr, size_t size, std::strin
                "Range provided is not fully contained in vma");
     it->second.name = name;
 }
-
 VAddr MemoryManager::SearchFree(VAddr virtual_addr, size_t size, u32 alignment) {
     // If the requested address is below the mapped range, start search from the lowest address
     auto min_search_address = impl.SystemManagedVirtualBase();
@@ -693,7 +693,7 @@ MemoryManager::DMemHandle MemoryManager::Split(DMemHandle dmem_handle, size_t of
     new_area.size -= offset_in_area;
 
     return dmem_map.emplace_hint(std::next(dmem_handle), new_area.base, new_area);
-}
+};
 
 int MemoryManager::GetDirectMemoryType(PAddr addr, int* directMemoryTypeOut,
                                        void** directMemoryStartOut, void** directMemoryEndOut) {

src/core/memory.cpp

@@ -4,125 +4,45 @@
 #include "libraries/kernel/threads/pthread.h"
 #include "thread.h"
 
-#include "core/libraries/kernel/threads/pthread.h"
-
 #ifdef _WIN64
 #include <windows.h>
-#include "common/ntapi.h"
 #else
 #include <pthread.h>
 #endif
 
 namespace Core {
 
-#ifdef _WIN64
-#define KGDT64_R3_DATA (0x28)
-#define KGDT64_R3_CODE (0x30)
-#define KGDT64_R3_CMTEB (0x50)
-#define RPL_MASK (0x03)
-
-#define INITIAL_FPUCW (0x037f)
-#define INITIAL_MXCSR_MASK (0xffbf)
-#define EFLAGS_INTERRUPT_MASK (0x200)
-
-void InitializeTeb(INITIAL_TEB* teb, const ::Libraries::Kernel::PthreadAttr* attr) {
-    teb->StackBase = (void*)((u64)attr->stackaddr_attr + attr->stacksize_attr);
-    teb->StackLimit = nullptr;
-    teb->StackAllocationBase = attr->stackaddr_attr;
-}
-
-void InitializeContext(CONTEXT* ctx, ThreadFunc func, void* arg,
-                       const ::Libraries::Kernel::PthreadAttr* attr) {
-    /* Note: The stack has to be reversed */
-    ctx->Rsp = (u64)attr->stackaddr_attr + attr->stacksize_attr;
-    ctx->Rbp = (u64)attr->stackaddr_attr + attr->stacksize_attr;
-    ctx->Rcx = (u64)arg;
-    ctx->Rip = (u64)func;
-
-    ctx->SegGs = KGDT64_R3_DATA | RPL_MASK;
-    ctx->SegEs = KGDT64_R3_DATA | RPL_MASK;
-    ctx->SegDs = KGDT64_R3_DATA | RPL_MASK;
-    ctx->SegCs = KGDT64_R3_CODE | RPL_MASK;
-    ctx->SegSs = KGDT64_R3_DATA | RPL_MASK;
-    ctx->SegFs = KGDT64_R3_CMTEB | RPL_MASK;
+Thread::Thread() : native_handle{0} {}
 
-    ctx->EFlags = 0x3000 | EFLAGS_INTERRUPT_MASK;
-    ctx->MxCsr = INITIAL_MXCSR;
+Thread::~Thread() {}
 
-    ctx->FltSave.ControlWord = INITIAL_FPUCW;
-    ctx->FltSave.MxCsr = INITIAL_MXCSR;
-    ctx->FltSave.MxCsr_Mask = INITIAL_MXCSR_MASK;
-
-    ctx->ContextFlags =
-        CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_SEGMENTS | CONTEXT_FLOATING_POINT;
-}
-#endif
-
-NativeThread::NativeThread() : native_handle{0} {}
-
-NativeThread::~NativeThread() {}
-
-int NativeThread::Create(ThreadFunc func, void* arg, const ::Libraries::Kernel::PthreadAttr* attr) {
-#ifndef _WIN64
+int Thread::Create(ThreadFunc func, void* arg, const ::Libraries::Kernel::PthreadAttr* attr) {
+#ifdef _WIN64
+    native_handle = CreateThread(nullptr, 0, (LPTHREAD_START_ROUTINE)func, arg, 0, nullptr);
+    return native_handle ? 0 : -1;
+#else
     pthread_t* pthr = reinterpret_cast<pthread_t*>(&native_handle);
     pthread_attr_t pattr;
     pthread_attr_init(&pattr);
     pthread_attr_setstack(&pattr, attr->stackaddr_attr, attr->stacksize_attr);
     return pthread_create(pthr, &pattr, (PthreadFunc)func, arg);
-#else
-    CLIENT_ID clientId{};
-    INITIAL_TEB teb{};
-    CONTEXT ctx{};
-
-    clientId.UniqueProcess = GetCurrentProcess();
-    clientId.UniqueThread = GetCurrentThread();
-
-    InitializeTeb(&teb, attr);
-    InitializeContext(&ctx, func, arg, attr);
-
-    return NtCreateThread(&native_handle, THREAD_ALL_ACCESS, nullptr, GetCurrentProcess(),
-                          &clientId, &ctx, &teb, false);
 #endif
 }
 
-void NativeThread::Exit() {
+void Thread::Exit() {
     if (!native_handle) {
         return;
     }
 
-    tid = 0;
-
 #ifdef _WIN64
-    NtClose(native_handle);
+    CloseHandle(native_handle);
     native_handle = nullptr;
 
-    /* The Windows kernel will free the stack
-       given at thread creation via INITIAL_TEB
-       (StackAllocationBase) upon thread termination.
-
-       In earlier Windows versions (NT4 to Windows Server 2003),
-       you could get around this via disabling FreeStackOnTermination
-       on the TEB. This has been removed since then.
-
-       To avoid this, we must forcefully set the TEB
-       deallocation stack pointer to NULL so ZwFreeVirtualMemory fails
-       in the kernel and our stack is not freed.
-     */
-    auto* teb = reinterpret_cast<TEB*>(NtCurrentTeb());
-    teb->DeallocationStack = nullptr;
-
-    NtTerminateThread(nullptr, 0);
+    // We call this assuming the thread has finished execution.
+    ExitThread(0);
 #else
     pthread_exit(nullptr);
 #endif
 }
 
-void NativeThread::Initialize() {
-#if _WIN64
-    tid = GetCurrentThreadId();
-#else
-    tid = (u64)pthread_self();
-#endif
-}
-
 } // namespace Core

src/core/thread.cpp

@@ -11,34 +11,27 @@ struct PthreadAttr;
 
 namespace Core {
 
-using ThreadFunc = void (*)(void*);
-using PthreadFunc = void* (*)(void*);
-
-class NativeThread {
+class Thread {
 public:
-    NativeThread();
-    ~NativeThread();
+    using ThreadFunc = void (*)(void*);
+    using PthreadFunc = void* (*)(void*);
+
+    Thread();
+    ~Thread();
 
     int Create(ThreadFunc func, void* arg, const ::Libraries::Kernel::PthreadAttr* attr);
     void Exit();
 
-    void Initialize();
-
     uintptr_t GetHandle() {
         return reinterpret_cast<uintptr_t>(native_handle);
     }
 
-    u64 GetTid() {
-        return tid;
-    }
-
 private:
-#ifdef _WIN64
+#if _WIN64
     void* native_handle;
 #else
     uintptr_t native_handle;
 #endif
-    u64 tid;
 };
 
 } // namespace Core

src/core/thread.h

@@ -46,7 +46,7 @@ Liverpool::~Liverpool() {
 }
 
 void Liverpool::Process(std::stop_token stoken) {
-    Common::SetCurrentThreadName("shadPS4:GpuCommandProcessor");
+    Common::SetCurrentThreadName("shadPS4:GPU_CommandProcessor");
 
     while (!stoken.stop_requested()) {
         {