From 8bf1ef26160c2137e6e5e2a9001ae4ef320bc09d Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Mon, 2 Sep 2013 13:18:02 -0700 Subject: [PATCH 1/7] Add handlers for delay and sleep callbacks. --- Core/HLE/sceKernelThread.cpp | 86 ++++++++++++++++++++++++++++++++++-- 1 file changed, 82 insertions(+), 4 deletions(-) diff --git a/Core/HLE/sceKernelThread.cpp b/Core/HLE/sceKernelThread.cpp index 4ec222173d..ef728c6282 100644 --- a/Core/HLE/sceKernelThread.cpp +++ b/Core/HLE/sceKernelThread.cpp @@ -820,6 +820,9 @@ MipsCallManager mipsCalls; int actionAfterCallback; int actionAfterMipsCall; +// When inside a callback, delays are "paused", and rechecked after the callback returns. +std::map pausedDelays; + // Doesn't need state saving. WaitTypeFuncs waitTypeFuncs[NUM_WAITTYPES]; @@ -892,16 +895,85 @@ Thread *__GetCurrentThread() { return NULL; } -u32 __KernelMipsCallReturnAddress() -{ +u32 __KernelMipsCallReturnAddress() { return cbReturnHackAddr; } -u32 __KernelInterruptReturnAddress() -{ +u32 __KernelInterruptReturnAddress() { return intReturnHackAddr; } +void __KernelDelayBeginCallback(SceUID threadID, SceUID prevCallbackId) { + SceUID pauseKey = prevCallbackId == 0 ? threadID : prevCallbackId; + + u32 error; + SceUID waitID = __KernelGetWaitID(threadID, WAITTYPE_DELAY, error); + if (waitID == threadID) { + // This means two callbacks in a row. PSP crashes if the same callback runs inside itself. + // TODO: Handle this better? + if (pausedDelays.find(pauseKey) != pausedDelays.end()) + return; + + s64 cyclesLeft = CoreTiming::UnscheduleEvent(eventScheduledWakeup, threadID); + pausedDelays[pauseKey] = CoreTiming::GetTicks() + cyclesLeft; + + DEBUG_LOG(HLE, "sceKernelDelayThreadCB: Suspending delay for callback"); + } + else + WARN_LOG_REPORT(HLE, "sceKernelDelayThreadCB: beginning callback with bad wait?"); +} + +void __KernelDelayEndCallback(SceUID threadID, SceUID prevCallbackId, u32 &returnValue) { + SceUID pauseKey = prevCallbackId == 0 ? threadID : prevCallbackId; + + if (pausedDelays.find(pauseKey) == pausedDelays.end()) + { + // This probably should not happen. + WARN_LOG_REPORT(HLE, "sceKernelDelayThreadCB: cannot find delay deadline"); + __KernelResumeThreadFromWait(threadID, 0); + return; + } + + u64 delayDeadline = pausedDelays[pauseKey]; + pausedDelays.erase(pauseKey); + + // TODO: Don't wake up if __KernelCurHasReadyCallbacks()? + + s64 cyclesLeft = delayDeadline - CoreTiming::GetTicks(); + if (cyclesLeft < 0) + __KernelResumeThreadFromWait(threadID, 0); + else + { + CoreTiming::ScheduleEvent(cyclesLeft, eventScheduledWakeup, __KernelGetCurThread()); + DEBUG_LOG(HLE, "sceKernelDelayThreadCB: Resuming delay after callback"); + } +} + +void __KernelSleepBeginCallback(SceUID threadID, SceUID prevCallbackId) { + DEBUG_LOG(HLE, "sceKernelSleepThreadCB: Suspending sleep for callback"); +} + +void __KernelSleepEndCallback(SceUID threadID, SceUID prevCallbackId, u32 &returnValue) { + u32 error; + Thread *thread = kernelObjects.Get(threadID, error); + if (!thread) + { + // This probably should not happen. + WARN_LOG_REPORT(HLE, "sceKernelSleepThreadCB: thread deleted?"); + return; + } + + // TODO: Don't wake up if __KernelCurHasReadyCallbacks()? + + if (thread->nt.wakeupCount > 0) { + thread->nt.wakeupCount--; + DEBUG_LOG(HLE, "sceKernelSleepThreadCB: resume from callback, wakeupCount decremented to %i", thread->nt.wakeupCount); + __KernelResumeThreadFromWait(threadID, 0); + } else { + DEBUG_LOG(HLE, "sceKernelDelayThreadCB: Resuming sleep after callback"); + } +} + u32 __KernelSetThreadRA(SceUID threadID, u32 nid) { u32 newRA; @@ -998,6 +1070,9 @@ void __KernelThreadingInit() __KernelListenThreadEnd(__KernelCancelWakeup); __KernelListenThreadEnd(__KernelCancelThreadEndTimeout); + + __KernelRegisterWaitTypeFuncs(WAITTYPE_DELAY, __KernelDelayBeginCallback, __KernelDelayEndCallback); + __KernelRegisterWaitTypeFuncs(WAITTYPE_SLEEP, __KernelSleepBeginCallback, __KernelSleepEndCallback); } void __KernelThreadingDoState(PointerWrap &p) @@ -1029,6 +1104,8 @@ void __KernelThreadingDoState(PointerWrap &p) p.Do(actionAfterCallback); __KernelRestoreActionType(actionAfterCallback, ActionAfterCallback::Create); + p.Do(pausedDelays); + hleCurrentThreadName = __KernelGetThreadName(currentThread); lastSwitchCycles = CoreTiming::GetTicks(); @@ -1214,6 +1291,7 @@ void __KernelThreadingShutdown() currentThread = 0; intReturnHackAddr = 0; hleCurrentThreadName = NULL; + pausedDelays.clear(); } const char *__KernelGetThreadName(SceUID threadID) From 722b878428a45ce3fc8ad77de2de2397f9f84c71 Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Mon, 2 Sep 2013 13:40:41 -0700 Subject: [PATCH 2/7] Fix sceKernelReferThreadRunStatus() layout. Was missing size, so all fields were wrong. --- Core/HLE/sceKernelThread.cpp | 43 ++++++++++++++++++++++++++---------- 1 file changed, 31 insertions(+), 12 deletions(-) diff --git a/Core/HLE/sceKernelThread.cpp b/Core/HLE/sceKernelThread.cpp index ef728c6282..b1b546f8c9 100644 --- a/Core/HLE/sceKernelThread.cpp +++ b/Core/HLE/sceKernelThread.cpp @@ -158,7 +158,22 @@ typedef WaitType WaitType_le; typedef swap_struct_t > WaitType_le; #endif -// Real PSP struct, don't change the fields +// Real PSP struct, don't change the fields. +struct SceKernelThreadRunStatus +{ + SceSize_le size; + u32_le status; + s32_le currentPriority; + WaitType_le waitType; + SceUID_le waitID; + s32_le wakeupCount; + SceKernelSysClock runForClocks; + s32_le numInterruptPreempts; + s32_le numThreadPreempts; + s32_le numReleases; +}; + +// Real PSP struct, don't change the fields. struct NativeThread { u32_le nativeSize; @@ -174,7 +189,7 @@ struct NativeThread s32_le initialPriority; s32_le currentPriority; - WaitType waitType; + WaitType_le waitType; SceUID_le waitID; s32_le wakeupCount; s32_le exitStatus; @@ -1425,16 +1440,20 @@ u32 sceKernelReferThreadRunStatus(u32 threadID, u32 statusPtr) if (!Memory::IsValidAddress(statusPtr)) return -1; - Memory::Write_U32(t->nt.status, statusPtr); - Memory::Write_U32(t->nt.currentPriority, statusPtr + 4); - Memory::Write_U32(t->nt.waitType, statusPtr + 8); - Memory::Write_U32(t->nt.waitID, statusPtr + 12); - Memory::Write_U32(t->nt.wakeupCount, statusPtr + 16); - Memory::Write_U32(t->nt.runForClocks.lo, statusPtr + 20); - Memory::Write_U32(t->nt.runForClocks.hi, statusPtr + 24); - Memory::Write_U32(t->nt.numInterruptPreempts, statusPtr + 28); - Memory::Write_U32(t->nt.numThreadPreempts, statusPtr + 32); - Memory::Write_U32(t->nt.numReleases, statusPtr + 36); + PSPPointer runStatus; + runStatus = statusPtr; + + // TODO: Check size? + runStatus->size = sizeof(SceKernelThreadRunStatus); + runStatus->status = t->nt.status; + runStatus->currentPriority = t->nt.currentPriority; + runStatus->waitType = t->nt.waitType; + runStatus->waitID = t->nt.waitID; + runStatus->wakeupCount = t->nt.wakeupCount; + runStatus->runForClocks = t->nt.runForClocks; + runStatus->numInterruptPreempts = t->nt.numInterruptPreempts; + runStatus->numThreadPreempts = t->nt.numThreadPreempts; + runStatus->numReleases = t->nt.numReleases; return 0; } From 648dd5f154d3a32fb9ba0b846a972cf1c56a8ce3 Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Mon, 2 Sep 2013 13:40:59 -0700 Subject: [PATCH 3/7] Don't allow sceKernelWakeupThread() on cur thread. I don't know why you wouldn't allow this, but the PSP firmware doesn't. --- Core/HLE/sceKernelThread.cpp | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/Core/HLE/sceKernelThread.cpp b/Core/HLE/sceKernelThread.cpp index b1b546f8c9..397baa769c 100644 --- a/Core/HLE/sceKernelThread.cpp +++ b/Core/HLE/sceKernelThread.cpp @@ -2570,6 +2570,12 @@ bool __KernelThreadSortPriority(SceUID thread1, SceUID thread2) ////////////////////////////////////////////////////////////////////////// int sceKernelWakeupThread(SceUID uid) { + if (uid == currentThread) + { + WARN_LOG_REPORT(HLE, "sceKernelWakeupThread(%i): unable to wakeup current thread", uid); + return SCE_KERNEL_ERROR_ILLEGAL_THID; + } + u32 error; Thread *t = kernelObjects.Get(uid, error); if (t) From 3903f27dfd52329a4c10743df6fe4a8d08afa3ab Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Mon, 2 Sep 2013 15:11:49 -0700 Subject: [PATCH 4/7] Add handlers for callbacks during mbx waits. --- Core/HLE/sceKernelEventFlag.cpp | 1 - Core/HLE/sceKernelMbx.cpp | 143 +++++++++++++++++++++++++++++--- 2 files changed, 132 insertions(+), 12 deletions(-) diff --git a/Core/HLE/sceKernelEventFlag.cpp b/Core/HLE/sceKernelEventFlag.cpp index a281879d9a..49c88fc1f3 100644 --- a/Core/HLE/sceKernelEventFlag.cpp +++ b/Core/HLE/sceKernelEventFlag.cpp @@ -203,7 +203,6 @@ void __KernelEventFlagBeginCallback(SceUID threadID, SceUID prevCallbackId) EventFlag *flag = flagID == 0 ? NULL : kernelObjects.Get(flagID, error); if (flag) { - // This means two callbacks in a row. PSP crashes if the same callback runs inside itself. // TODO: Handle this better? if (flag->pausedWaits.find(pauseKey) != flag->pausedWaits.end()) diff --git a/Core/HLE/sceKernelMbx.cpp b/Core/HLE/sceKernelMbx.cpp index 86bc38fe7c..451f87bb44 100644 --- a/Core/HLE/sceKernelMbx.cpp +++ b/Core/HLE/sceKernelMbx.cpp @@ -15,6 +15,8 @@ // Official git repository and contact information can be found at // https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/. +#include +#include #include "sceKernel.h" #include "sceKernelThread.h" #include "sceKernelMbx.h" @@ -31,8 +33,9 @@ const int PSP_MBX_ERROR_DUPLICATE_MSG = 0x800201C9; struct MbxWaitingThread { - SceUID first; - u32 second; + SceUID threadID; + u32 packetAddr; + u64 pausedTimeout; }; void __KernelMbxTimeout(u64 userdata, int cyclesLate); @@ -63,7 +66,7 @@ struct Mbx : public KernelObject { for (std::vector::iterator it = waitingThreads.begin(); it != waitingThreads.end(); it++) { - if (__KernelGetThreadPrio(id) < __KernelGetThreadPrio((*it).first)) + if (__KernelGetThreadPrio(id) < __KernelGetThreadPrio(it->threadID)) { MbxWaitingThread waiting = {id, addr}; waitingThreads.insert(it, waiting); @@ -169,17 +172,24 @@ struct Mbx : public KernelObject p.Do(nmb); MbxWaitingThread mwt = {0}; p.Do(waitingThreads, mwt); + p.Do(pausedWaits); p.DoMarker("Mbx"); } NativeMbx nmb; std::vector waitingThreads; + // Key is the callback id it was for, or if no callback, the thread id. + std::map pausedWaits; }; +void __KernelMbxBeginCallback(SceUID threadID, SceUID prevCallbackId); +void __KernelMbxEndCallback(SceUID threadID, SceUID prevCallbackId, u32 &returnValue); + void __KernelMbxInit() { mbxWaitTimer = CoreTiming::RegisterEvent("MbxTimeout", __KernelMbxTimeout); + __KernelRegisterWaitTypeFuncs(WAITTYPE_MBX, __KernelMbxBeginCallback, __KernelMbxEndCallback); } void __KernelMbxDoState(PointerWrap &p) @@ -196,8 +206,8 @@ KernelObject *__KernelMbxObject() bool __KernelUnlockMbxForThread(Mbx *m, MbxWaitingThread &th, u32 &error, int result, bool &wokeThreads) { - SceUID waitID = __KernelGetWaitID(th.first, WAITTYPE_MBX, error); - u32 timeoutPtr = __KernelGetWaitTimeoutPtr(th.first, error); + SceUID waitID = __KernelGetWaitID(th.threadID, WAITTYPE_MBX, error); + u32 timeoutPtr = __KernelGetWaitTimeoutPtr(th.threadID, error); // The waitID may be different after a timeout. if (waitID != m->GetUID()) @@ -206,15 +216,118 @@ bool __KernelUnlockMbxForThread(Mbx *m, MbxWaitingThread &th, u32 &error, int re if (timeoutPtr != 0 && mbxWaitTimer != -1) { // Remove any event for this thread. - s64 cyclesLeft = CoreTiming::UnscheduleEvent(mbxWaitTimer, th.first); + s64 cyclesLeft = CoreTiming::UnscheduleEvent(mbxWaitTimer, th.threadID); Memory::Write_U32((u32) cyclesToUs(cyclesLeft), timeoutPtr); } - __KernelResumeThreadFromWait(th.first, result); + __KernelResumeThreadFromWait(th.threadID, result); wokeThreads = true; return true; } +void __KernelMbxBeginCallback(SceUID threadID, SceUID prevCallbackId) +{ + SceUID pauseKey = prevCallbackId == 0 ? threadID : prevCallbackId; + + u32 error; + SceUID mbxID = __KernelGetWaitID(threadID, WAITTYPE_MBX, error); + u32 timeoutPtr = __KernelGetWaitTimeoutPtr(threadID, error); + Mbx *m = mbxID == 0 ? NULL : kernelObjects.Get(mbxID, error); + if (m) + { + // This means two callbacks in a row. PSP crashes if the same callback runs inside itself. + // TODO: Handle this better? + if (m->pausedWaits.find(pauseKey) != m->pausedWaits.end()) + return; + + MbxWaitingThread waitData = {0}; + for (size_t i = 0; i < m->waitingThreads.size(); i++) + { + MbxWaitingThread *t = &m->waitingThreads[i]; + if (t->threadID == threadID) + { + waitData = *t; + // TODO: Hmm, what about priority/fifo order? Does it lose its place in line? + m->waitingThreads.erase(m->waitingThreads.begin() + i); + break; + } + } + + if (waitData.threadID != threadID) + { + ERROR_LOG_REPORT(HLE, "sceKernelReceiveMbxCB: wait not found to pause for callback"); + return; + } + + if (timeoutPtr != 0 && mbxWaitTimer != -1) + { + s64 cyclesLeft = CoreTiming::UnscheduleEvent(mbxWaitTimer, threadID); + waitData.pausedTimeout = CoreTiming::GetTicks() + cyclesLeft; + } + else + waitData.pausedTimeout = 0; + + m->pausedWaits[pauseKey] = waitData; + DEBUG_LOG(HLE, "sceKernelReceiveMbxCB: Suspending mbx wait for callback"); + } + else + WARN_LOG_REPORT(HLE, "sceKernelReceiveMbxCB: beginning callback with bad wait id?"); +} + +void __KernelMbxEndCallback(SceUID threadID, SceUID prevCallbackId, u32 &returnValue) +{ + SceUID pauseKey = prevCallbackId == 0 ? threadID : prevCallbackId; + + u32 error; + SceUID mbxID = __KernelGetWaitID(threadID, WAITTYPE_MBX, error); + u32 timeoutPtr = __KernelGetWaitTimeoutPtr(threadID, error); + Mbx *m = mbxID == 0 ? NULL : kernelObjects.Get(mbxID, error); + if (!m || m->pausedWaits.find(pauseKey) == m->pausedWaits.end()) + { + // TODO: Since it was deleted, we don't know how long was actually left. + // For now, we just say the full time was taken. + if (timeoutPtr != 0 && mbxWaitTimer != -1) + Memory::Write_U32(0, timeoutPtr); + + __KernelResumeThreadFromWait(threadID, SCE_KERNEL_ERROR_WAIT_DELETE); + return; + } + + MbxWaitingThread waitData = m->pausedWaits[pauseKey]; + u64 waitDeadline = waitData.pausedTimeout; + m->pausedWaits.erase(pauseKey); + + // TODO: Don't wake up if __KernelCurHasReadyCallbacks()? + + bool wokeThreads; + // Attempt to unlock. + if (m->nmb.numMessages > 0 && __KernelUnlockMbxForThread(m, waitData, error, 0, wokeThreads)) + { + m->ReceiveMessage(waitData.packetAddr); + return; + } + + // We only check if it timed out if it couldn't receive. + s64 cyclesLeft = waitDeadline - CoreTiming::GetTicks(); + if (cyclesLeft < 0 && waitDeadline != 0) + { + if (timeoutPtr != 0 && mbxWaitTimer != -1) + Memory::Write_U32(0, timeoutPtr); + + __KernelResumeThreadFromWait(threadID, SCE_KERNEL_ERROR_WAIT_TIMEOUT); + } + else + { + if (timeoutPtr != 0 && mbxWaitTimer != -1) + CoreTiming::ScheduleEvent(cyclesLeft, mbxWaitTimer, __KernelGetCurThread()); + + // TODO: Should this not go at the end? + m->waitingThreads.push_back(waitData); + + DEBUG_LOG(HLE, "sceKernelReceiveMbxCB: Resuming mbx wait from callback"); + } +} + void __KernelMbxTimeout(u64 userdata, int cyclesLate) { SceUID threadID = (SceUID)userdata; @@ -260,7 +373,7 @@ void __KernelMbxRemoveThread(Mbx *m, SceUID threadID) for (size_t i = 0; i < m->waitingThreads.size(); i++) { MbxWaitingThread *t = &m->waitingThreads[i]; - if (t->first == threadID) + if (t->threadID == threadID) { m->waitingThreads.erase(m->waitingThreads.begin() + i); break; @@ -276,7 +389,7 @@ std::vector::iterator __KernelMbxFindPriority(std::vectorfirst); + u32 iter_prio = __KernelGetThreadPrio(iter->threadID); if (iter_prio < best_prio) { best = iter; @@ -386,8 +499,8 @@ int sceKernelSendMbx(SceUID id, u32 packetAddr) if (wokeThreads) { - DEBUG_LOG(HLE, "sceKernelSendMbx(%i, %08x): threads waiting, resuming %d", id, packetAddr, t.first); - Memory::Write_U32(packetAddr, t.second); + DEBUG_LOG(HLE, "sceKernelSendMbx(%i, %08x): threads waiting, resuming %d", id, packetAddr, t.threadID); + Memory::Write_U32(packetAddr, t.packetAddr); hleReSchedule("mbx sent"); // We don't need to do anything else, finish here. @@ -564,6 +677,14 @@ int sceKernelReferMbxStatus(SceUID id, u32 infoAddr) for (int i = 0, n = m->nmb.numMessages; i < n; ++i) m->nmb.packetListHead = Memory::Read_U32(m->nmb.packetListHead); + for (auto iter = m->waitingThreads.begin(); iter != m->waitingThreads.end(); ++iter) + { + SceUID waitID = __KernelGetWaitID(iter->threadID, WAITTYPE_MBX, error); + // The thread is no longer waiting for this, clean it up. + if (waitID != id) + m->waitingThreads.erase(iter--); + } + // For whatever reason, it won't write if the size (first member) is 0. if (Memory::Read_U32(infoAddr) != 0) { From 1bf974aff64a37f5546a6d21c6a7f0e88dfa0b8a Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Mon, 2 Sep 2013 16:29:00 -0700 Subject: [PATCH 5/7] Implement VPL/FPL callback handlers. Smells like time to refactor, there are less differences than I expected. --- Core/HLE/sceKernelEventFlag.cpp | 4 +- Core/HLE/sceKernelMbx.cpp | 4 +- Core/HLE/sceKernelMemory.cpp | 218 ++++++++++++++++++++++++++++++++ Core/HLE/sceKernelMutex.cpp | 8 +- Core/HLE/sceKernelSemaphore.cpp | 4 +- Core/HLE/sceKernelThread.cpp | 6 +- Core/HLE/sceKernelThread.h | 2 +- 7 files changed, 232 insertions(+), 14 deletions(-) diff --git a/Core/HLE/sceKernelEventFlag.cpp b/Core/HLE/sceKernelEventFlag.cpp index 49c88fc1f3..6e140c1a76 100644 --- a/Core/HLE/sceKernelEventFlag.cpp +++ b/Core/HLE/sceKernelEventFlag.cpp @@ -108,7 +108,7 @@ enum PspEventFlagWaitTypes int eventFlagWaitTimer = -1; void __KernelEventFlagBeginCallback(SceUID threadID, SceUID prevCallbackId); -void __KernelEventFlagEndCallback(SceUID threadID, SceUID prevCallbackId, u32 &returnValue); +void __KernelEventFlagEndCallback(SceUID threadID, SceUID prevCallbackId); void __KernelEventFlagInit() { @@ -242,7 +242,7 @@ void __KernelEventFlagBeginCallback(SceUID threadID, SceUID prevCallbackId) WARN_LOG_REPORT(HLE, "sceKernelWaitEventFlagCB: beginning callback with bad wait id?"); } -void __KernelEventFlagEndCallback(SceUID threadID, SceUID prevCallbackId, u32 &returnValue) +void __KernelEventFlagEndCallback(SceUID threadID, SceUID prevCallbackId) { SceUID pauseKey = prevCallbackId == 0 ? threadID : prevCallbackId; diff --git a/Core/HLE/sceKernelMbx.cpp b/Core/HLE/sceKernelMbx.cpp index 451f87bb44..54482b03aa 100644 --- a/Core/HLE/sceKernelMbx.cpp +++ b/Core/HLE/sceKernelMbx.cpp @@ -184,7 +184,7 @@ struct Mbx : public KernelObject }; void __KernelMbxBeginCallback(SceUID threadID, SceUID prevCallbackId); -void __KernelMbxEndCallback(SceUID threadID, SceUID prevCallbackId, u32 &returnValue); +void __KernelMbxEndCallback(SceUID threadID, SceUID prevCallbackId); void __KernelMbxInit() { @@ -274,7 +274,7 @@ void __KernelMbxBeginCallback(SceUID threadID, SceUID prevCallbackId) WARN_LOG_REPORT(HLE, "sceKernelReceiveMbxCB: beginning callback with bad wait id?"); } -void __KernelMbxEndCallback(SceUID threadID, SceUID prevCallbackId, u32 &returnValue) +void __KernelMbxEndCallback(SceUID threadID, SceUID prevCallbackId) { SceUID pauseKey = prevCallbackId == 0 ? threadID : prevCallbackId; diff --git a/Core/HLE/sceKernelMemory.cpp b/Core/HLE/sceKernelMemory.cpp index 195e18de95..9f1634def7 100644 --- a/Core/HLE/sceKernelMemory.cpp +++ b/Core/HLE/sceKernelMemory.cpp @@ -17,6 +17,8 @@ #include #include +#include +#include #include "Core/HLE/HLE.h" #include "Core/System.h" #include "Core/MIPS/MIPS.h" @@ -53,6 +55,7 @@ struct FplWaitingThread { SceUID threadID; u32 addrPtr; + u64 pausedTimeout; }; struct NativeFPL @@ -118,6 +121,7 @@ struct FPL : public KernelObject p.Do(nextBlock); FplWaitingThread dv = {0}; p.Do(waitingThreads, dv); + p.Do(pausedWaits); p.DoMarker("FPL"); } @@ -127,12 +131,15 @@ struct FPL : public KernelObject int alignedSize; int nextBlock; std::vector waitingThreads; + // Key is the callback id it was for, or if no callback, the thread id. + std::map pausedWaits; }; struct VplWaitingThread { SceUID threadID; u32 addrPtr; + u64 pausedTimeout; }; struct SceKernelVplInfo @@ -162,18 +169,26 @@ struct VPL : public KernelObject VplWaitingThread dv = {0}; p.Do(waitingThreads, dv); alloc.DoState(p); + p.Do(pausedWaits); p.DoMarker("VPL"); } SceKernelVplInfo nv; u32 address; std::vector waitingThreads; + // Key is the callback id it was for, or if no callback, the thread id. + std::map pausedWaits; BlockAllocator alloc; }; void __KernelVplTimeout(u64 userdata, int cyclesLate); void __KernelFplTimeout(u64 userdata, int cyclesLate); +void __KernelVplBeginCallback(SceUID threadID, SceUID prevCallbackId); +void __KernelVplEndCallback(SceUID threadID, SceUID prevCallbackId); +void __KernelFplBeginCallback(SceUID threadID, SceUID prevCallbackId); +void __KernelFplEndCallback(SceUID threadID, SceUID prevCallbackId); + void __KernelMemoryInit() { kernelMemory.Init(PSP_GetKernelMemoryBase(), PSP_GetKernelMemoryEnd()-PSP_GetKernelMemoryBase()); @@ -187,6 +202,9 @@ void __KernelMemoryInit() sdkVersion_ = 0; compilerVersion_ = 0; memset(tlsUsedIndexes, 0, sizeof(tlsUsedIndexes)); + + __KernelRegisterWaitTypeFuncs(WAITTYPE_VPL, __KernelVplBeginCallback, __KernelVplEndCallback); + __KernelRegisterWaitTypeFuncs(WAITTYPE_FPL, __KernelFplBeginCallback, __KernelFplEndCallback); } void __KernelMemoryDoState(PointerWrap &p) @@ -258,6 +276,106 @@ bool __KernelUnlockFplForThread(FPL *fpl, FplWaitingThread &threadInfo, u32 &err return true; } +void __KernelFplBeginCallback(SceUID threadID, SceUID prevCallbackId) +{ + SceUID pauseKey = prevCallbackId == 0 ? threadID : prevCallbackId; + + u32 error; + SceUID fplID = __KernelGetWaitID(threadID, WAITTYPE_FPL, error); + u32 timeoutPtr = __KernelGetWaitTimeoutPtr(threadID, error); + FPL *fpl = fplID == 0 ? NULL : kernelObjects.Get(fplID, error); + if (fpl) + { + // This means two callbacks in a row. PSP crashes if the same callback runs inside itself. + // TODO: Handle this better? + if (fpl->pausedWaits.find(pauseKey) != fpl->pausedWaits.end()) + return; + + FplWaitingThread waitData = {0}; + for (size_t i = 0; i < fpl->waitingThreads.size(); i++) + { + FplWaitingThread *t = &fpl->waitingThreads[i]; + if (t->threadID == threadID) + { + waitData = *t; + // TODO: Hmm, what about priority/fifo order? Does it lose its place in line? + fpl->waitingThreads.erase(fpl->waitingThreads.begin() + i); + break; + } + } + + if (waitData.threadID != threadID) + { + ERROR_LOG_REPORT(HLE, "sceKernelAllocateFplCB: wait not found to pause for callback"); + return; + } + + if (timeoutPtr != 0 && fplWaitTimer != -1) + { + s64 cyclesLeft = CoreTiming::UnscheduleEvent(fplWaitTimer, threadID); + waitData.pausedTimeout = CoreTiming::GetTicks() + cyclesLeft; + } + else + waitData.pausedTimeout = 0; + + fpl->pausedWaits[pauseKey] = waitData; + DEBUG_LOG(HLE, "sceKernelAllocateFplCB: Suspending fpl wait for callback"); + } + else + WARN_LOG_REPORT(HLE, "sceKernelAllocateFplCB: beginning callback with bad wait id?"); +} + +void __KernelFplEndCallback(SceUID threadID, SceUID prevCallbackId) +{ + SceUID pauseKey = prevCallbackId == 0 ? threadID : prevCallbackId; + + u32 error; + SceUID fplID = __KernelGetWaitID(threadID, WAITTYPE_FPL, error); + u32 timeoutPtr = __KernelGetWaitTimeoutPtr(threadID, error); + FPL *fpl = fplID == 0 ? NULL : kernelObjects.Get(fplID, error); + if (!fpl || fpl->pausedWaits.find(pauseKey) == fpl->pausedWaits.end()) + { + // TODO: Since it was deleted, we don't know how long was actually left. + // For now, we just say the full time was taken. + if (timeoutPtr != 0 && fplWaitTimer != -1) + Memory::Write_U32(0, timeoutPtr); + + __KernelResumeThreadFromWait(threadID, SCE_KERNEL_ERROR_WAIT_DELETE); + return; + } + + FplWaitingThread waitData = fpl->pausedWaits[pauseKey]; + u64 waitDeadline = waitData.pausedTimeout; + fpl->pausedWaits.erase(pauseKey); + + // TODO: Don't wake up if __KernelCurHasReadyCallbacks()? + + bool wokeThreads; + // Attempt to unlock. + if (__KernelUnlockFplForThread(fpl, waitData, error, 0, wokeThreads)) + return; + + // We only check if it timed out if it couldn't receive. + s64 cyclesLeft = waitDeadline - CoreTiming::GetTicks(); + if (cyclesLeft < 0 && waitDeadline != 0) + { + if (timeoutPtr != 0 && fplWaitTimer != -1) + Memory::Write_U32(0, timeoutPtr); + + __KernelResumeThreadFromWait(threadID, SCE_KERNEL_ERROR_WAIT_TIMEOUT); + } + else + { + if (timeoutPtr != 0 && fplWaitTimer != -1) + CoreTiming::ScheduleEvent(cyclesLeft, fplWaitTimer, __KernelGetCurThread()); + + // TODO: Should this not go at the end? + fpl->waitingThreads.push_back(waitData); + + DEBUG_LOG(HLE, "sceKernelAllocateFplCB: Resuming fpl wait from callback"); + } +} + void __KernelFplRemoveThread(FPL *fpl, SceUID threadID) { for (size_t i = 0; i < fpl->waitingThreads.size(); i++) @@ -1147,6 +1265,106 @@ bool __KernelUnlockVplForThread(VPL *vpl, VplWaitingThread &threadInfo, u32 &err return true; } +void __KernelVplBeginCallback(SceUID threadID, SceUID prevCallbackId) +{ + SceUID pauseKey = prevCallbackId == 0 ? threadID : prevCallbackId; + + u32 error; + SceUID vplID = __KernelGetWaitID(threadID, WAITTYPE_VPL, error); + u32 timeoutPtr = __KernelGetWaitTimeoutPtr(threadID, error); + VPL *vpl = vplID == 0 ? NULL : kernelObjects.Get(vplID, error); + if (vpl) + { + // This means two callbacks in a row. PSP crashes if the same callback runs inside itself. + // TODO: Handle this better? + if (vpl->pausedWaits.find(pauseKey) != vpl->pausedWaits.end()) + return; + + VplWaitingThread waitData = {0}; + for (size_t i = 0; i < vpl->waitingThreads.size(); i++) + { + VplWaitingThread *t = &vpl->waitingThreads[i]; + if (t->threadID == threadID) + { + waitData = *t; + // TODO: Hmm, what about priority/fifo order? Does it lose its place in line? + vpl->waitingThreads.erase(vpl->waitingThreads.begin() + i); + break; + } + } + + if (waitData.threadID != threadID) + { + ERROR_LOG_REPORT(HLE, "sceKernelAllocateVplCB: wait not found to pause for callback"); + return; + } + + if (timeoutPtr != 0 && vplWaitTimer != -1) + { + s64 cyclesLeft = CoreTiming::UnscheduleEvent(vplWaitTimer, threadID); + waitData.pausedTimeout = CoreTiming::GetTicks() + cyclesLeft; + } + else + waitData.pausedTimeout = 0; + + vpl->pausedWaits[pauseKey] = waitData; + DEBUG_LOG(HLE, "sceKernelAllocateVplCB: Suspending vpl wait for callback"); + } + else + WARN_LOG_REPORT(HLE, "sceKernelAllocateVplCB: beginning callback with bad wait id?"); +} + +void __KernelVplEndCallback(SceUID threadID, SceUID prevCallbackId) +{ + SceUID pauseKey = prevCallbackId == 0 ? threadID : prevCallbackId; + + u32 error; + SceUID vplID = __KernelGetWaitID(threadID, WAITTYPE_VPL, error); + u32 timeoutPtr = __KernelGetWaitTimeoutPtr(threadID, error); + VPL *vpl = vplID == 0 ? NULL : kernelObjects.Get(vplID, error); + if (!vpl || vpl->pausedWaits.find(pauseKey) == vpl->pausedWaits.end()) + { + // TODO: Since it was deleted, we don't know how long was actually left. + // For now, we just say the full time was taken. + if (timeoutPtr != 0 && vplWaitTimer != -1) + Memory::Write_U32(0, timeoutPtr); + + __KernelResumeThreadFromWait(threadID, SCE_KERNEL_ERROR_WAIT_DELETE); + return; + } + + VplWaitingThread waitData = vpl->pausedWaits[pauseKey]; + u64 waitDeadline = waitData.pausedTimeout; + vpl->pausedWaits.erase(pauseKey); + + // TODO: Don't wake up if __KernelCurHasReadyCallbacks()? + + bool wokeThreads; + // Attempt to unlock. + if (__KernelUnlockVplForThread(vpl, waitData, error, 0, wokeThreads)) + return; + + // We only check if it timed out if it couldn't receive. + s64 cyclesLeft = waitDeadline - CoreTiming::GetTicks(); + if (cyclesLeft < 0 && waitDeadline != 0) + { + if (timeoutPtr != 0 && vplWaitTimer != -1) + Memory::Write_U32(0, timeoutPtr); + + __KernelResumeThreadFromWait(threadID, SCE_KERNEL_ERROR_WAIT_TIMEOUT); + } + else + { + if (timeoutPtr != 0 && vplWaitTimer != -1) + CoreTiming::ScheduleEvent(cyclesLeft, vplWaitTimer, __KernelGetCurThread()); + + // TODO: Should this not go at the end? + vpl->waitingThreads.push_back(waitData); + + DEBUG_LOG(HLE, "sceKernelAllocateVplCB: Resuming vpl wait from callback"); + } +} + void __KernelVplRemoveThread(VPL *vpl, SceUID threadID) { for (size_t i = 0; i < vpl->waitingThreads.size(); i++) diff --git a/Core/HLE/sceKernelMutex.cpp b/Core/HLE/sceKernelMutex.cpp index 1b1ebcb6d9..df4375843d 100644 --- a/Core/HLE/sceKernelMutex.cpp +++ b/Core/HLE/sceKernelMutex.cpp @@ -151,9 +151,9 @@ typedef std::multimap MutexMap; static MutexMap mutexHeldLocks; void __KernelMutexBeginCallback(SceUID threadID, SceUID prevCallbackId); -void __KernelMutexEndCallback(SceUID threadID, SceUID prevCallbackId, u32 &returnValue); +void __KernelMutexEndCallback(SceUID threadID, SceUID prevCallbackId); void __KernelLwMutexBeginCallback(SceUID threadID, SceUID prevCallbackId); -void __KernelLwMutexEndCallback(SceUID threadID, SceUID prevCallbackId, u32 &returnValue); +void __KernelLwMutexEndCallback(SceUID threadID, SceUID prevCallbackId); void __KernelMutexInit() { @@ -306,7 +306,7 @@ void __KernelMutexBeginCallback(SceUID threadID, SceUID prevCallbackId) WARN_LOG_REPORT(HLE, "sceKernelLockMutexCB: beginning callback with bad wait id?"); } -void __KernelMutexEndCallback(SceUID threadID, SceUID prevCallbackId, u32 &returnValue) +void __KernelMutexEndCallback(SceUID threadID, SceUID prevCallbackId) { SceUID pauseKey = prevCallbackId == 0 ? threadID : prevCallbackId; @@ -1028,7 +1028,7 @@ void __KernelLwMutexBeginCallback(SceUID threadID, SceUID prevCallbackId) WARN_LOG_REPORT(HLE, "sceKernelLockLwMutexCB: beginning callback with bad wait id?"); } -void __KernelLwMutexEndCallback(SceUID threadID, SceUID prevCallbackId, u32 &returnValue) +void __KernelLwMutexEndCallback(SceUID threadID, SceUID prevCallbackId) { SceUID pauseKey = prevCallbackId == 0 ? threadID : prevCallbackId; diff --git a/Core/HLE/sceKernelSemaphore.cpp b/Core/HLE/sceKernelSemaphore.cpp index d085acca3a..5060d3e024 100644 --- a/Core/HLE/sceKernelSemaphore.cpp +++ b/Core/HLE/sceKernelSemaphore.cpp @@ -78,7 +78,7 @@ struct Semaphore : public KernelObject static int semaWaitTimer = -1; void __KernelSemaBeginCallback(SceUID threadID, SceUID prevCallbackId); -void __KernelSemaEndCallback(SceUID threadID, SceUID prevCallbackId, u32 &returnValue); +void __KernelSemaEndCallback(SceUID threadID, SceUID prevCallbackId); void __KernelSemaInit() { @@ -164,7 +164,7 @@ void __KernelSemaBeginCallback(SceUID threadID, SceUID prevCallbackId) WARN_LOG_REPORT(HLE, "sceKernelWaitSemaCB: beginning callback with bad wait id?"); } -void __KernelSemaEndCallback(SceUID threadID, SceUID prevCallbackId, u32 &returnValue) +void __KernelSemaEndCallback(SceUID threadID, SceUID prevCallbackId) { SceUID pauseKey = prevCallbackId == 0 ? threadID : prevCallbackId; diff --git a/Core/HLE/sceKernelThread.cpp b/Core/HLE/sceKernelThread.cpp index 397baa769c..2a7d71d6c3 100644 --- a/Core/HLE/sceKernelThread.cpp +++ b/Core/HLE/sceKernelThread.cpp @@ -938,7 +938,7 @@ void __KernelDelayBeginCallback(SceUID threadID, SceUID prevCallbackId) { WARN_LOG_REPORT(HLE, "sceKernelDelayThreadCB: beginning callback with bad wait?"); } -void __KernelDelayEndCallback(SceUID threadID, SceUID prevCallbackId, u32 &returnValue) { +void __KernelDelayEndCallback(SceUID threadID, SceUID prevCallbackId) { SceUID pauseKey = prevCallbackId == 0 ? threadID : prevCallbackId; if (pausedDelays.find(pauseKey) == pausedDelays.end()) @@ -968,7 +968,7 @@ void __KernelSleepBeginCallback(SceUID threadID, SceUID prevCallbackId) { DEBUG_LOG(HLE, "sceKernelSleepThreadCB: Suspending sleep for callback"); } -void __KernelSleepEndCallback(SceUID threadID, SceUID prevCallbackId, u32 &returnValue) { +void __KernelSleepEndCallback(SceUID threadID, SceUID prevCallbackId) { u32 error; Thread *thread = kernelObjects.Get(threadID, error); if (!thread) @@ -3364,7 +3364,7 @@ void __KernelReturnFromMipsCall() if (cur->nt.waitType != WAITTYPE_NONE) { if (waitTypeFuncs[cur->nt.waitType].endFunc != NULL && call->cbId > 0) - waitTypeFuncs[cur->nt.waitType].endFunc(cur->GetUID(), cur->currentCallbackId, currentMIPS->r[MIPS_REG_V0]); + waitTypeFuncs[cur->nt.waitType].endFunc(cur->GetUID(), cur->currentCallbackId); } // yeah! back in the real world, let's keep going. Should we process more callbacks? diff --git a/Core/HLE/sceKernelThread.h b/Core/HLE/sceKernelThread.h index aece5716d7..8f723b3cc7 100644 --- a/Core/HLE/sceKernelThread.h +++ b/Core/HLE/sceKernelThread.h @@ -103,7 +103,7 @@ const char *getWaitTypeName(WaitType type); // Suspend wait and timeout while a thread enters a callback. typedef void (* WaitBeginCallbackFunc)(SceUID threadID, SceUID prevCallbackId); // Resume wait and timeout as a thread exits a callback. -typedef void (* WaitEndCallbackFunc)(SceUID threadID, SceUID prevCallbackId, u32 &returnValue); +typedef void (* WaitEndCallbackFunc)(SceUID threadID, SceUID prevCallbackId); void __KernelRegisterWaitTypeFuncs(WaitType type, WaitBeginCallbackFunc beginFunc, WaitEndCallbackFunc endFunc); From b20bb3b60966374618a943100ee75d7dafd65797 Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Mon, 2 Sep 2013 17:59:47 -0700 Subject: [PATCH 6/7] Refactor down the begin/end callback stuff. --- CMakeLists.txt | 1 + Core/Core.vcxproj | 1 + Core/Core.vcxproj.filters | 3 + Core/HLE/KernelWaitHelpers.h | 188 ++++++++++++++++++++++++++++++ Core/HLE/sceKernelEventFlag.cpp | 117 +++---------------- Core/HLE/sceKernelMbx.cpp | 120 ++++--------------- Core/HLE/sceKernelMemory.cpp | 197 +++----------------------------- Core/HLE/sceKernelMutex.cpp | 185 ++++++------------------------ Core/HLE/sceKernelSemaphore.cpp | 83 ++------------ Core/HLE/sceKernelThread.cpp | 36 +++--- Core/HLE/sceKernelThread.h | 2 +- 11 files changed, 311 insertions(+), 622 deletions(-) create mode 100644 Core/HLE/KernelWaitHelpers.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 5a954889ae..c5c5b4b80c 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -801,6 +801,7 @@ add_library(${CoreLibName} ${CoreLinkType} Core/HLE/HLE.h Core/HLE/HLETables.cpp Core/HLE/HLETables.h + Core/HLE/KernelWaitHelpers.h Core/HLE/__sceAudio.cpp Core/HLE/__sceAudio.h Core/HLE/sceAtrac.cpp diff --git a/Core/Core.vcxproj b/Core/Core.vcxproj index 850a8af2d5..0c3cb71a0a 100644 --- a/Core/Core.vcxproj +++ b/Core/Core.vcxproj @@ -429,6 +429,7 @@ + diff --git a/Core/Core.vcxproj.filters b/Core/Core.vcxproj.filters index 9cbfcc44f9..a4f1c75666 100644 --- a/Core/Core.vcxproj.filters +++ b/Core/Core.vcxproj.filters @@ -891,6 +891,9 @@ MIPS\PPC + + HLE\Kernel + diff --git a/Core/HLE/KernelWaitHelpers.h b/Core/HLE/KernelWaitHelpers.h new file mode 100644 index 0000000000..e5edb005df --- /dev/null +++ b/Core/HLE/KernelWaitHelpers.h @@ -0,0 +1,188 @@ +// Copyright (c) 2012- PPSSPP Project. + +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, version 2.0 or later versions. + +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License 2.0 for more details. + +// A copy of the GPL 2.0 should have been included with the program. +// If not, see http://www.gnu.org/licenses/ + +// Official git repository and contact information can be found at +// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/. + +#pragma once + +#include +#include +#include +#include "Core/HLE/sceKernelThread.h" + +namespace HLEKernel +{ + +template +inline bool WaitPauseHelperUpdate(SceUID pauseKey, SceUID threadID, std::vector &waitingThreads, std::map &pausedWaits, u64 pauseTimeout) { + WaitInfoType waitData = {0}; + for (size_t i = 0; i < waitingThreads.size(); i++) { + WaitInfoType *t = &waitingThreads[i]; + if (t->threadID == threadID) + { + waitData = *t; + // TODO: Hmm, what about priority/fifo order? Does it lose its place in line? + waitingThreads.erase(waitingThreads.begin() + i); + break; + } + } + + if (waitData.threadID != threadID) + return false; + + waitData.pausedTimeout = pauseTimeout; + pausedWaits[pauseKey] = waitData; + return true; +} + +template <> +inline bool WaitPauseHelperUpdate(SceUID pauseKey, SceUID threadID, std::vector &waitingThreads, std::map &pausedWaits, u64 pauseTimeout) { + // TODO: Hmm, what about priority/fifo order? Does it lose its place in line? + waitingThreads.erase(std::remove(waitingThreads.begin(), waitingThreads.end(), threadID), waitingThreads.end()); + pausedWaits[pauseKey] = pauseTimeout; + return true; +} + +template +inline u64 WaitPauseHelperGet(SceUID pauseKey, SceUID threadID, std::map &pausedWaits, WaitInfoType &waitData) { + waitData = pausedWaits[pauseKey]; + u64 waitDeadline = waitData.pausedTimeout; + pausedWaits.erase(pauseKey); + return waitDeadline; +} + +template <> +inline u64 WaitPauseHelperGet(SceUID pauseKey, SceUID threadID, std::map &pausedWaits, SceUID &waitData) { + waitData = threadID; + u64 waitDeadline = pausedWaits[pauseKey]; + pausedWaits.erase(pauseKey); + return waitDeadline; +} + +enum WaitBeginEndCallbackResult { + WAIT_CB_BAD_WAIT_DATA = -2, + WAIT_CB_BAD_WAIT_ID = -1, + WAIT_CB_SUCCESS = 0, + WAIT_CB_RESUMED_WAIT = 1, +}; + +template +WaitBeginEndCallbackResult WaitBeginCallback(SceUID threadID, SceUID prevCallbackId, int waitTimer, std::vector &waitingThreads, std::map &pausedWaits, bool doTimeout = true) { + SceUID pauseKey = prevCallbackId == 0 ? threadID : prevCallbackId; + + // This means two callbacks in a row. PSP crashes if the same callback runs inside itself. + // TODO: Handle this better? + if (pausedWaits.find(pauseKey) != pausedWaits.end()) { + return WAIT_CB_SUCCESS; + } + + u64 pausedTimeout = 0; + if (doTimeout && waitTimer != -1) { + s64 cyclesLeft = CoreTiming::UnscheduleEvent(waitTimer, threadID); + pausedTimeout = CoreTiming::GetTicks() + cyclesLeft; + } + + if (!WaitPauseHelperUpdate(pauseKey, threadID, waitingThreads, pausedWaits, pausedTimeout)) { + return WAIT_CB_BAD_WAIT_DATA; + } + + return WAIT_CB_SUCCESS; +} + +template +WaitBeginEndCallbackResult WaitBeginCallback(SceUID threadID, SceUID prevCallbackId, int waitTimer) { + u32 error; + SceUID uid = __KernelGetWaitID(threadID, waitType, error); + u32 timeoutPtr = __KernelGetWaitTimeoutPtr(threadID, error); + KO *ko = uid == 0 ? NULL : kernelObjects.Get(uid, error); + if (ko) { + return WaitBeginCallback(threadID, prevCallbackId, waitTimer, ko->waitingThreads, ko->pausedWaits, timeoutPtr != 0); + } else { + return WAIT_CB_BAD_WAIT_ID; + } +} + +template +WaitBeginEndCallbackResult WaitEndCallback(SceUID threadID, SceUID prevCallbackId, int waitTimer, TryUnlockFunc TryUnlock, std::vector &waitingThreads, std::map &pausedWaits) { + SceUID pauseKey = prevCallbackId == 0 ? threadID : prevCallbackId; + + // Note: Cancel does not affect suspended semaphore waits, probably same for others. + + u32 error; + SceUID uid = __KernelGetWaitID(threadID, waitType, error); + u32 timeoutPtr = __KernelGetWaitTimeoutPtr(threadID, error); + KO *ko = uid == 0 ? NULL : kernelObjects.Get(uid, error); + if (!ko || pausedWaits.find(pauseKey) == pausedWaits.end()) { + // TODO: Since it was deleted, we don't know how long was actually left. + // For now, we just say the full time was taken. + if (timeoutPtr != 0 && waitTimer != -1) { + Memory::Write_U32(0, timeoutPtr); + } + + __KernelResumeThreadFromWait(threadID, SCE_KERNEL_ERROR_WAIT_DELETE); + return WAIT_CB_SUCCESS; + } + + WaitInfoType waitData; + u64 waitDeadline = WaitPauseHelperGet(pauseKey, threadID, pausedWaits, waitData); + + // TODO: Don't wake up if __KernelCurHasReadyCallbacks()? + + bool wokeThreads; + // Attempt to unlock. + if (TryUnlock(ko, waitData, error, 0, wokeThreads)) { + return WAIT_CB_SUCCESS; + } + + // We only check if it timed out if it couldn't unlock. + s64 cyclesLeft = waitDeadline - CoreTiming::GetTicks(); + if (cyclesLeft < 0 && waitDeadline != 0) { + if (timeoutPtr != 0 && waitTimer != -1) + Memory::Write_U32(0, timeoutPtr); + + __KernelResumeThreadFromWait(threadID, SCE_KERNEL_ERROR_WAIT_TIMEOUT); + return WAIT_CB_SUCCESS; + } else { + if (timeoutPtr != 0 && waitTimer != -1) { + CoreTiming::ScheduleEvent(cyclesLeft, waitTimer, __KernelGetCurThread()); + } + + // TODO: Should this not go at the end? + waitingThreads.push_back(waitData); + return WAIT_CB_RESUMED_WAIT; + } +} + +template +WaitBeginEndCallbackResult WaitEndCallback(SceUID threadID, SceUID prevCallbackId, int waitTimer, TryUnlockFunc TryUnlock) { + u32 error; + SceUID uid = __KernelGetWaitID(threadID, waitType, error); + u32 timeoutPtr = __KernelGetWaitTimeoutPtr(threadID, error); + KO *ko = uid == 0 ? NULL : kernelObjects.Get(uid, error); + if (!ko) { + // TODO: Since it was deleted, we don't know how long was actually left. + // For now, we just say the full time was taken. + if (timeoutPtr != 0 && waitTimer != -1) { + Memory::Write_U32(0, timeoutPtr); + } + + __KernelResumeThreadFromWait(threadID, SCE_KERNEL_ERROR_WAIT_DELETE); + return WAIT_CB_SUCCESS; + } + + return WaitEndCallback(threadID, prevCallbackId, waitTimer, TryUnlock, ko->waitingThreads, ko->pausedWaits); +} + +}; diff --git a/Core/HLE/sceKernelEventFlag.cpp b/Core/HLE/sceKernelEventFlag.cpp index 6e140c1a76..bf2cd26fdc 100644 --- a/Core/HLE/sceKernelEventFlag.cpp +++ b/Core/HLE/sceKernelEventFlag.cpp @@ -26,6 +26,7 @@ #include "Core/HLE/sceKernel.h" #include "Core/HLE/sceKernelThread.h" #include "Core/HLE/sceKernelEventFlag.h" +#include "Core/HLE/KernelWaitHelpers.h" void __KernelEventFlagTimeout(u64 userdata, int cycleslate); @@ -41,7 +42,7 @@ struct NativeEventFlag struct EventFlagTh { - SceUID tid; + SceUID threadID; u32 bits; u32 wait; u32 outAddr; @@ -149,8 +150,8 @@ bool __KernelEventFlagMatches(u32_le *pattern, u32 bits, u8 wait, u32 outAddr) bool __KernelUnlockEventFlagForThread(EventFlag *e, EventFlagTh &th, u32 &error, int result, bool &wokeThreads) { - SceUID waitID = __KernelGetWaitID(th.tid, WAITTYPE_EVENTFLAG, error); - u32 timeoutPtr = __KernelGetWaitTimeoutPtr(th.tid, error); + SceUID waitID = __KernelGetWaitID(th.threadID, WAITTYPE_EVENTFLAG, error); + u32 timeoutPtr = __KernelGetWaitTimeoutPtr(th.threadID, error); // The waitID may be different after a timeout. if (waitID != e->GetUID()) @@ -172,11 +173,11 @@ bool __KernelUnlockEventFlagForThread(EventFlag *e, EventFlagTh &th, u32 &error, if (timeoutPtr != 0 && eventFlagWaitTimer != -1) { // Remove any event for this thread. - s64 cyclesLeft = CoreTiming::UnscheduleEvent(eventFlagWaitTimer, th.tid); + s64 cyclesLeft = CoreTiming::UnscheduleEvent(eventFlagWaitTimer, th.threadID); Memory::Write_U32((u32) cyclesToUs(cyclesLeft), timeoutPtr); } - __KernelResumeThreadFromWait(th.tid, result); + __KernelResumeThreadFromWait(th.threadID, result); wokeThreads = true; return true; } @@ -195,102 +196,20 @@ bool __KernelClearEventFlagThreads(EventFlag *e, int reason) void __KernelEventFlagBeginCallback(SceUID threadID, SceUID prevCallbackId) { - SceUID pauseKey = prevCallbackId == 0 ? threadID : prevCallbackId; - - u32 error; - SceUID flagID = __KernelGetWaitID(threadID, WAITTYPE_EVENTFLAG, error); - u32 timeoutPtr = __KernelGetWaitTimeoutPtr(threadID, error); - EventFlag *flag = flagID == 0 ? NULL : kernelObjects.Get(flagID, error); - if (flag) - { - // This means two callbacks in a row. PSP crashes if the same callback runs inside itself. - // TODO: Handle this better? - if (flag->pausedWaits.find(pauseKey) != flag->pausedWaits.end()) - return; - - EventFlagTh waitData = {0}; - for (size_t i = 0; i < flag->waitingThreads.size(); i++) - { - EventFlagTh *t = &flag->waitingThreads[i]; - if (t->tid == threadID) - { - waitData = *t; - // TODO: Hmm, what about priority/fifo order? Does it lose its place in line? - flag->waitingThreads.erase(flag->waitingThreads.begin() + i); - break; - } - } - - if (waitData.tid != threadID) - { - ERROR_LOG_REPORT(HLE, "sceKernelWaitEventFlagCB: wait not found to pause for callback"); - return; - } - - if (timeoutPtr != 0 && eventFlagWaitTimer != -1) - { - s64 cyclesLeft = CoreTiming::UnscheduleEvent(eventFlagWaitTimer, threadID); - waitData.pausedTimeout = CoreTiming::GetTicks() + cyclesLeft; - } - else - waitData.pausedTimeout = 0; - - flag->pausedWaits[pauseKey] = waitData; - DEBUG_LOG(HLE, "sceKernelWaitEventFlagCB: Suspending lock wait for callback"); - } + auto result = HLEKernel::WaitBeginCallback(threadID, prevCallbackId, eventFlagWaitTimer); + if (result == HLEKernel::WAIT_CB_SUCCESS) + DEBUG_LOG(HLE, "sceKernelWaitEventFlagCB: Suspending lock wait for callback") + else if (result == HLEKernel::WAIT_CB_BAD_WAIT_DATA) + ERROR_LOG_REPORT(HLE, "sceKernelWaitEventFlagCB: wait not found to pause for callback") else WARN_LOG_REPORT(HLE, "sceKernelWaitEventFlagCB: beginning callback with bad wait id?"); } void __KernelEventFlagEndCallback(SceUID threadID, SceUID prevCallbackId) { - SceUID pauseKey = prevCallbackId == 0 ? threadID : prevCallbackId; - - u32 error; - SceUID flagID = __KernelGetWaitID(threadID, WAITTYPE_EVENTFLAG, error); - u32 timeoutPtr = __KernelGetWaitTimeoutPtr(threadID, error); - EventFlag *flag = flagID == 0 ? NULL : kernelObjects.Get(flagID, error); - if (!flag || flag->pausedWaits.find(pauseKey) == flag->pausedWaits.end()) - { - // TODO: Since it was deleted, we don't know how long was actually left. - // For now, we just say the full time was taken. - if (timeoutPtr != 0 && eventFlagWaitTimer != -1) - Memory::Write_U32(0, timeoutPtr); - - __KernelResumeThreadFromWait(threadID, SCE_KERNEL_ERROR_WAIT_DELETE); - return; - } - - EventFlagTh waitData = flag->pausedWaits[pauseKey]; - u64 waitDeadline = waitData.pausedTimeout; - flag->pausedWaits.erase(pauseKey); - - // TODO: Don't wake up if __KernelCurHasReadyCallbacks()? - - bool wokeThreads; - // Attempt to unlock. - if (__KernelUnlockEventFlagForThread(flag, waitData, error, 0, wokeThreads)) - return; - - // We only check if it timed out if it couldn't unlock. - s64 cyclesLeft = waitDeadline - CoreTiming::GetTicks(); - if (cyclesLeft < 0 && waitDeadline != 0) - { - if (timeoutPtr != 0 && eventFlagWaitTimer != -1) - Memory::Write_U32(0, timeoutPtr); - - __KernelResumeThreadFromWait(threadID, SCE_KERNEL_ERROR_WAIT_TIMEOUT); - } - else - { - if (timeoutPtr != 0 && eventFlagWaitTimer != -1) - CoreTiming::ScheduleEvent(cyclesLeft, eventFlagWaitTimer, __KernelGetCurThread()); - - // TODO: Should this not go at the end? - flag->waitingThreads.push_back(waitData); - + auto result = HLEKernel::WaitEndCallback(threadID, prevCallbackId, eventFlagWaitTimer, __KernelUnlockEventFlagForThread); + if (result == HLEKernel::WAIT_CB_RESUMED_WAIT) DEBUG_LOG(HLE, "sceKernelWaitEventFlagCB: Resuming lock wait for callback"); - } } //SceUID sceKernelCreateEventFlag(const char *name, int attr, int bits, SceKernelEventFlagOptParam *opt); @@ -448,7 +367,7 @@ void __KernelEventFlagTimeout(u64 userdata, int cycleslate) for (size_t i = 0; i < e->waitingThreads.size(); i++) { EventFlagTh *t = &e->waitingThreads[i]; - if (t->tid == threadID) + if (t->threadID == threadID) { bool wokeThreads; @@ -485,7 +404,7 @@ void __KernelEventFlagRemoveThread(EventFlag *e, SceUID threadID) for (size_t i = 0; i < e->waitingThreads.size(); i++) { EventFlagTh *t = &e->waitingThreads[i]; - if (t->tid == threadID) + if (t->threadID == threadID) { e->waitingThreads.erase(e->waitingThreads.begin() + i); break; @@ -538,7 +457,7 @@ int sceKernelWaitEventFlag(SceUID id, u32 bits, u32 wait, u32 outBitsPtr, u32 ti DEBUG_LOG(HLE, "sceKernelWaitEventFlag(%i, %08x, %i, %08x, %08x): waiting", id, bits, wait, outBitsPtr, timeoutPtr); // No match - must wait. - th.tid = __KernelGetCurThread(); + th.threadID = __KernelGetCurThread(); th.bits = bits; th.wait = wait; // If < 5ms, sometimes hardware doesn't write this, but it's unpredictable. @@ -613,7 +532,7 @@ int sceKernelWaitEventFlagCB(SceUID id, u32 bits, u32 wait, u32 outBitsPtr, u32 DEBUG_LOG(HLE, "sceKernelWaitEventFlagCB(%i, %08x, %i, %08x, %08x): waiting", id, bits, wait, outBitsPtr, timeoutPtr); // No match - must wait. - th.tid = __KernelGetCurThread(); + th.threadID = __KernelGetCurThread(); th.bits = bits; th.wait = wait; // If < 5ms, sometimes hardware doesn't write this, but it's unpredictable. @@ -707,7 +626,7 @@ u32 sceKernelReferEventFlagStatus(SceUID id, u32 statusPtr) for (auto iter = e->waitingThreads.begin(); iter != e->waitingThreads.end(); ++iter) { - SceUID waitID = __KernelGetWaitID(iter->tid, WAITTYPE_EVENTFLAG, error); + SceUID waitID = __KernelGetWaitID(iter->threadID, WAITTYPE_EVENTFLAG, error); // The thread is no longer waiting for this, clean it up. if (waitID != id) e->waitingThreads.erase(iter--); diff --git a/Core/HLE/sceKernelMbx.cpp b/Core/HLE/sceKernelMbx.cpp index 54482b03aa..986eef63ff 100644 --- a/Core/HLE/sceKernelMbx.cpp +++ b/Core/HLE/sceKernelMbx.cpp @@ -17,13 +17,14 @@ #include #include -#include "sceKernel.h" -#include "sceKernelThread.h" -#include "sceKernelMbx.h" -#include "HLE.h" +#include "Common/ChunkFile.h" +#include "Core/HLE/sceKernel.h" +#include "Core/HLE/sceKernelThread.h" +#include "Core/HLE/sceKernelMbx.h" +#include "Core/HLE/HLE.h" #include "Core/CoreTiming.h" #include "Core/Reporting.h" -#include "ChunkFile.h" +#include "Core/HLE/KernelWaitHelpers.h" #define SCE_KERNEL_MBA_THPRI 0x100 #define SCE_KERNEL_MBA_MSPRI 0x400 @@ -225,107 +226,32 @@ bool __KernelUnlockMbxForThread(Mbx *m, MbxWaitingThread &th, u32 &error, int re return true; } +bool __KernelUnlockMbxForThreadCheck(Mbx *m, MbxWaitingThread &waitData, u32 &error, int result, bool &wokeThreads) +{ + if (m->nmb.numMessages > 0 && __KernelUnlockMbxForThread(m, waitData, error, 0, wokeThreads)) + { + m->ReceiveMessage(waitData.packetAddr); + return true; + } + return false; +} + void __KernelMbxBeginCallback(SceUID threadID, SceUID prevCallbackId) { - SceUID pauseKey = prevCallbackId == 0 ? threadID : prevCallbackId; - - u32 error; - SceUID mbxID = __KernelGetWaitID(threadID, WAITTYPE_MBX, error); - u32 timeoutPtr = __KernelGetWaitTimeoutPtr(threadID, error); - Mbx *m = mbxID == 0 ? NULL : kernelObjects.Get(mbxID, error); - if (m) - { - // This means two callbacks in a row. PSP crashes if the same callback runs inside itself. - // TODO: Handle this better? - if (m->pausedWaits.find(pauseKey) != m->pausedWaits.end()) - return; - - MbxWaitingThread waitData = {0}; - for (size_t i = 0; i < m->waitingThreads.size(); i++) - { - MbxWaitingThread *t = &m->waitingThreads[i]; - if (t->threadID == threadID) - { - waitData = *t; - // TODO: Hmm, what about priority/fifo order? Does it lose its place in line? - m->waitingThreads.erase(m->waitingThreads.begin() + i); - break; - } - } - - if (waitData.threadID != threadID) - { - ERROR_LOG_REPORT(HLE, "sceKernelReceiveMbxCB: wait not found to pause for callback"); - return; - } - - if (timeoutPtr != 0 && mbxWaitTimer != -1) - { - s64 cyclesLeft = CoreTiming::UnscheduleEvent(mbxWaitTimer, threadID); - waitData.pausedTimeout = CoreTiming::GetTicks() + cyclesLeft; - } - else - waitData.pausedTimeout = 0; - - m->pausedWaits[pauseKey] = waitData; - DEBUG_LOG(HLE, "sceKernelReceiveMbxCB: Suspending mbx wait for callback"); - } + auto result = HLEKernel::WaitBeginCallback(threadID, prevCallbackId, mbxWaitTimer); + if (result == HLEKernel::WAIT_CB_SUCCESS) + DEBUG_LOG(HLE, "sceKernelReceiveMbxCB: Suspending mbx wait for callback") + else if (result == HLEKernel::WAIT_CB_BAD_WAIT_DATA) + ERROR_LOG_REPORT(HLE, "sceKernelReceiveMbxCB: wait not found to pause for callback") else WARN_LOG_REPORT(HLE, "sceKernelReceiveMbxCB: beginning callback with bad wait id?"); } void __KernelMbxEndCallback(SceUID threadID, SceUID prevCallbackId) { - SceUID pauseKey = prevCallbackId == 0 ? threadID : prevCallbackId; - - u32 error; - SceUID mbxID = __KernelGetWaitID(threadID, WAITTYPE_MBX, error); - u32 timeoutPtr = __KernelGetWaitTimeoutPtr(threadID, error); - Mbx *m = mbxID == 0 ? NULL : kernelObjects.Get(mbxID, error); - if (!m || m->pausedWaits.find(pauseKey) == m->pausedWaits.end()) - { - // TODO: Since it was deleted, we don't know how long was actually left. - // For now, we just say the full time was taken. - if (timeoutPtr != 0 && mbxWaitTimer != -1) - Memory::Write_U32(0, timeoutPtr); - - __KernelResumeThreadFromWait(threadID, SCE_KERNEL_ERROR_WAIT_DELETE); - return; - } - - MbxWaitingThread waitData = m->pausedWaits[pauseKey]; - u64 waitDeadline = waitData.pausedTimeout; - m->pausedWaits.erase(pauseKey); - - // TODO: Don't wake up if __KernelCurHasReadyCallbacks()? - - bool wokeThreads; - // Attempt to unlock. - if (m->nmb.numMessages > 0 && __KernelUnlockMbxForThread(m, waitData, error, 0, wokeThreads)) - { - m->ReceiveMessage(waitData.packetAddr); - return; - } - - // We only check if it timed out if it couldn't receive. - s64 cyclesLeft = waitDeadline - CoreTiming::GetTicks(); - if (cyclesLeft < 0 && waitDeadline != 0) - { - if (timeoutPtr != 0 && mbxWaitTimer != -1) - Memory::Write_U32(0, timeoutPtr); - - __KernelResumeThreadFromWait(threadID, SCE_KERNEL_ERROR_WAIT_TIMEOUT); - } - else - { - if (timeoutPtr != 0 && mbxWaitTimer != -1) - CoreTiming::ScheduleEvent(cyclesLeft, mbxWaitTimer, __KernelGetCurThread()); - - // TODO: Should this not go at the end? - m->waitingThreads.push_back(waitData); - + auto result = HLEKernel::WaitEndCallback(threadID, prevCallbackId, mbxWaitTimer, __KernelUnlockMbxForThreadCheck); + if (result == HLEKernel::WAIT_CB_RESUMED_WAIT) DEBUG_LOG(HLE, "sceKernelReceiveMbxCB: Resuming mbx wait from callback"); - } } void __KernelMbxTimeout(u64 userdata, int cyclesLate) diff --git a/Core/HLE/sceKernelMemory.cpp b/Core/HLE/sceKernelMemory.cpp index 9f1634def7..ac7e5e24b0 100644 --- a/Core/HLE/sceKernelMemory.cpp +++ b/Core/HLE/sceKernelMemory.cpp @@ -30,6 +30,7 @@ #include "Core/HLE/sceKernelThread.h" #include "Core/HLE/sceKernelInterrupt.h" #include "Core/HLE/sceKernelMemory.h" +#include "Core/HLE/KernelWaitHelpers.h" const int TLS_NUM_INDEXES = 16; @@ -278,102 +279,20 @@ bool __KernelUnlockFplForThread(FPL *fpl, FplWaitingThread &threadInfo, u32 &err void __KernelFplBeginCallback(SceUID threadID, SceUID prevCallbackId) { - SceUID pauseKey = prevCallbackId == 0 ? threadID : prevCallbackId; - - u32 error; - SceUID fplID = __KernelGetWaitID(threadID, WAITTYPE_FPL, error); - u32 timeoutPtr = __KernelGetWaitTimeoutPtr(threadID, error); - FPL *fpl = fplID == 0 ? NULL : kernelObjects.Get(fplID, error); - if (fpl) - { - // This means two callbacks in a row. PSP crashes if the same callback runs inside itself. - // TODO: Handle this better? - if (fpl->pausedWaits.find(pauseKey) != fpl->pausedWaits.end()) - return; - - FplWaitingThread waitData = {0}; - for (size_t i = 0; i < fpl->waitingThreads.size(); i++) - { - FplWaitingThread *t = &fpl->waitingThreads[i]; - if (t->threadID == threadID) - { - waitData = *t; - // TODO: Hmm, what about priority/fifo order? Does it lose its place in line? - fpl->waitingThreads.erase(fpl->waitingThreads.begin() + i); - break; - } - } - - if (waitData.threadID != threadID) - { - ERROR_LOG_REPORT(HLE, "sceKernelAllocateFplCB: wait not found to pause for callback"); - return; - } - - if (timeoutPtr != 0 && fplWaitTimer != -1) - { - s64 cyclesLeft = CoreTiming::UnscheduleEvent(fplWaitTimer, threadID); - waitData.pausedTimeout = CoreTiming::GetTicks() + cyclesLeft; - } - else - waitData.pausedTimeout = 0; - - fpl->pausedWaits[pauseKey] = waitData; - DEBUG_LOG(HLE, "sceKernelAllocateFplCB: Suspending fpl wait for callback"); - } + auto result = HLEKernel::WaitBeginCallback(threadID, prevCallbackId, fplWaitTimer); + if (result == HLEKernel::WAIT_CB_SUCCESS) + DEBUG_LOG(HLE, "sceKernelAllocateFplCB: Suspending fpl wait for callback") + else if (result == HLEKernel::WAIT_CB_BAD_WAIT_DATA) + ERROR_LOG_REPORT(HLE, "sceKernelAllocateFplCB: wait not found to pause for callback") else WARN_LOG_REPORT(HLE, "sceKernelAllocateFplCB: beginning callback with bad wait id?"); } void __KernelFplEndCallback(SceUID threadID, SceUID prevCallbackId) { - SceUID pauseKey = prevCallbackId == 0 ? threadID : prevCallbackId; - - u32 error; - SceUID fplID = __KernelGetWaitID(threadID, WAITTYPE_FPL, error); - u32 timeoutPtr = __KernelGetWaitTimeoutPtr(threadID, error); - FPL *fpl = fplID == 0 ? NULL : kernelObjects.Get(fplID, error); - if (!fpl || fpl->pausedWaits.find(pauseKey) == fpl->pausedWaits.end()) - { - // TODO: Since it was deleted, we don't know how long was actually left. - // For now, we just say the full time was taken. - if (timeoutPtr != 0 && fplWaitTimer != -1) - Memory::Write_U32(0, timeoutPtr); - - __KernelResumeThreadFromWait(threadID, SCE_KERNEL_ERROR_WAIT_DELETE); - return; - } - - FplWaitingThread waitData = fpl->pausedWaits[pauseKey]; - u64 waitDeadline = waitData.pausedTimeout; - fpl->pausedWaits.erase(pauseKey); - - // TODO: Don't wake up if __KernelCurHasReadyCallbacks()? - - bool wokeThreads; - // Attempt to unlock. - if (__KernelUnlockFplForThread(fpl, waitData, error, 0, wokeThreads)) - return; - - // We only check if it timed out if it couldn't receive. - s64 cyclesLeft = waitDeadline - CoreTiming::GetTicks(); - if (cyclesLeft < 0 && waitDeadline != 0) - { - if (timeoutPtr != 0 && fplWaitTimer != -1) - Memory::Write_U32(0, timeoutPtr); - - __KernelResumeThreadFromWait(threadID, SCE_KERNEL_ERROR_WAIT_TIMEOUT); - } - else - { - if (timeoutPtr != 0 && fplWaitTimer != -1) - CoreTiming::ScheduleEvent(cyclesLeft, fplWaitTimer, __KernelGetCurThread()); - - // TODO: Should this not go at the end? - fpl->waitingThreads.push_back(waitData); - - DEBUG_LOG(HLE, "sceKernelAllocateFplCB: Resuming fpl wait from callback"); - } + auto result = HLEKernel::WaitEndCallback(threadID, prevCallbackId, fplWaitTimer, __KernelUnlockFplForThread); + if (result == HLEKernel::WAIT_CB_RESUMED_WAIT) + DEBUG_LOG(HLE, "sceKernelReceiveMbxCB: Resuming mbx wait from callback"); } void __KernelFplRemoveThread(FPL *fpl, SceUID threadID) @@ -1267,102 +1186,20 @@ bool __KernelUnlockVplForThread(VPL *vpl, VplWaitingThread &threadInfo, u32 &err void __KernelVplBeginCallback(SceUID threadID, SceUID prevCallbackId) { - SceUID pauseKey = prevCallbackId == 0 ? threadID : prevCallbackId; - - u32 error; - SceUID vplID = __KernelGetWaitID(threadID, WAITTYPE_VPL, error); - u32 timeoutPtr = __KernelGetWaitTimeoutPtr(threadID, error); - VPL *vpl = vplID == 0 ? NULL : kernelObjects.Get(vplID, error); - if (vpl) - { - // This means two callbacks in a row. PSP crashes if the same callback runs inside itself. - // TODO: Handle this better? - if (vpl->pausedWaits.find(pauseKey) != vpl->pausedWaits.end()) - return; - - VplWaitingThread waitData = {0}; - for (size_t i = 0; i < vpl->waitingThreads.size(); i++) - { - VplWaitingThread *t = &vpl->waitingThreads[i]; - if (t->threadID == threadID) - { - waitData = *t; - // TODO: Hmm, what about priority/fifo order? Does it lose its place in line? - vpl->waitingThreads.erase(vpl->waitingThreads.begin() + i); - break; - } - } - - if (waitData.threadID != threadID) - { - ERROR_LOG_REPORT(HLE, "sceKernelAllocateVplCB: wait not found to pause for callback"); - return; - } - - if (timeoutPtr != 0 && vplWaitTimer != -1) - { - s64 cyclesLeft = CoreTiming::UnscheduleEvent(vplWaitTimer, threadID); - waitData.pausedTimeout = CoreTiming::GetTicks() + cyclesLeft; - } - else - waitData.pausedTimeout = 0; - - vpl->pausedWaits[pauseKey] = waitData; - DEBUG_LOG(HLE, "sceKernelAllocateVplCB: Suspending vpl wait for callback"); - } + auto result = HLEKernel::WaitBeginCallback(threadID, prevCallbackId, vplWaitTimer); + if (result == HLEKernel::WAIT_CB_SUCCESS) + DEBUG_LOG(HLE, "sceKernelAllocateVplCB: Suspending vpl wait for callback") + else if (result == HLEKernel::WAIT_CB_BAD_WAIT_DATA) + ERROR_LOG_REPORT(HLE, "sceKernelAllocateVplCB: wait not found to pause for callback") else WARN_LOG_REPORT(HLE, "sceKernelAllocateVplCB: beginning callback with bad wait id?"); } void __KernelVplEndCallback(SceUID threadID, SceUID prevCallbackId) { - SceUID pauseKey = prevCallbackId == 0 ? threadID : prevCallbackId; - - u32 error; - SceUID vplID = __KernelGetWaitID(threadID, WAITTYPE_VPL, error); - u32 timeoutPtr = __KernelGetWaitTimeoutPtr(threadID, error); - VPL *vpl = vplID == 0 ? NULL : kernelObjects.Get(vplID, error); - if (!vpl || vpl->pausedWaits.find(pauseKey) == vpl->pausedWaits.end()) - { - // TODO: Since it was deleted, we don't know how long was actually left. - // For now, we just say the full time was taken. - if (timeoutPtr != 0 && vplWaitTimer != -1) - Memory::Write_U32(0, timeoutPtr); - - __KernelResumeThreadFromWait(threadID, SCE_KERNEL_ERROR_WAIT_DELETE); - return; - } - - VplWaitingThread waitData = vpl->pausedWaits[pauseKey]; - u64 waitDeadline = waitData.pausedTimeout; - vpl->pausedWaits.erase(pauseKey); - - // TODO: Don't wake up if __KernelCurHasReadyCallbacks()? - - bool wokeThreads; - // Attempt to unlock. - if (__KernelUnlockVplForThread(vpl, waitData, error, 0, wokeThreads)) - return; - - // We only check if it timed out if it couldn't receive. - s64 cyclesLeft = waitDeadline - CoreTiming::GetTicks(); - if (cyclesLeft < 0 && waitDeadline != 0) - { - if (timeoutPtr != 0 && vplWaitTimer != -1) - Memory::Write_U32(0, timeoutPtr); - - __KernelResumeThreadFromWait(threadID, SCE_KERNEL_ERROR_WAIT_TIMEOUT); - } - else - { - if (timeoutPtr != 0 && vplWaitTimer != -1) - CoreTiming::ScheduleEvent(cyclesLeft, vplWaitTimer, __KernelGetCurThread()); - - // TODO: Should this not go at the end? - vpl->waitingThreads.push_back(waitData); - - DEBUG_LOG(HLE, "sceKernelAllocateVplCB: Resuming vpl wait from callback"); - } + auto result = HLEKernel::WaitEndCallback(threadID, prevCallbackId, vplWaitTimer, __KernelUnlockVplForThread); + if (result == HLEKernel::WAIT_CB_RESUMED_WAIT) + DEBUG_LOG(HLE, "sceKernelReceiveMbxCB: Resuming mbx wait from callback"); } void __KernelVplRemoveThread(VPL *vpl, SceUID threadID) diff --git a/Core/HLE/sceKernelMutex.cpp b/Core/HLE/sceKernelMutex.cpp index df4375843d..73015078ae 100644 --- a/Core/HLE/sceKernelMutex.cpp +++ b/Core/HLE/sceKernelMutex.cpp @@ -17,14 +17,15 @@ #include #include -#include "HLE.h" -#include "../MIPS/MIPS.h" +#include "Common/ChunkFile.h" +#include "Core/HLE/HLE.h" +#include "Core/MIPS/MIPS.h" #include "Core/CoreTiming.h" #include "Core/Reporting.h" -#include "ChunkFile.h" -#include "sceKernel.h" -#include "sceKernelMutex.h" -#include "sceKernelThread.h" +#include "Core/HLE/sceKernel.h" +#include "Core/HLE/sceKernelMutex.h" +#include "Core/HLE/sceKernelThread.h" +#include "Core/HLE/KernelWaitHelpers.h" #define PSP_MUTEX_ATTR_FIFO 0 #define PSP_MUTEX_ATTR_PRIORITY 0x100 @@ -72,14 +73,14 @@ struct Mutex : public KernelObject p.Do(nm); SceUID dv = 0; p.Do(waitingThreads, dv); - p.Do(pausedWaitTimeouts); + p.Do(pausedWaits); p.DoMarker("Mutex"); } NativeMutex nm; std::vector waitingThreads; // Key is the callback id it was for, or if no callback, the thread id. - std::map pausedWaitTimeouts; + std::map pausedWaits; }; @@ -134,14 +135,14 @@ struct LwMutex : public KernelObject p.Do(nm); SceUID dv = 0; p.Do(waitingThreads, dv); - p.Do(pausedWaitTimeouts); + p.Do(pausedWaits); p.DoMarker("LwMutex"); } NativeLwMutex nm; std::vector waitingThreads; // Key is the callback id it was for, or if no callback, the thread id. - std::map pausedWaitTimeouts; + std::map pausedWaits; }; static int mutexWaitTimer = -1; @@ -274,85 +275,27 @@ bool __KernelUnlockMutexForThread(Mutex *mutex, SceUID threadID, u32 &error, int return true; } +bool __KernelUnlockMutexForThreadCheck(Mutex *mutex, SceUID threadID, u32 &error, int result, bool &wokeThreads) +{ + if (mutex->nm.lockThread == -1 && __KernelUnlockMutexForThread(mutex, threadID, error, 0)) + return true; + return false; +} + void __KernelMutexBeginCallback(SceUID threadID, SceUID prevCallbackId) { - SceUID pauseKey = prevCallbackId == 0 ? threadID : prevCallbackId; - - u32 error; - SceUID mutexID = __KernelGetWaitID(threadID, WAITTYPE_MUTEX, error); - u32 timeoutPtr = __KernelGetWaitTimeoutPtr(threadID, error); - Mutex *mutex = mutexID == 0 ? NULL : kernelObjects.Get(mutexID, error); - if (mutex) - { - // This means two callbacks in a row. PSP crashes if the same callback runs inside itself. - // TODO: Handle this better? - if (mutex->pausedWaitTimeouts.find(pauseKey) != mutex->pausedWaitTimeouts.end()) - return; - - if (timeoutPtr != 0 && mutexWaitTimer != -1) - { - s64 cyclesLeft = CoreTiming::UnscheduleEvent(mutexWaitTimer, threadID); - mutex->pausedWaitTimeouts[pauseKey] = CoreTiming::GetTicks() + cyclesLeft; - } - else - mutex->pausedWaitTimeouts[pauseKey] = 0; - - // TODO: Hmm, what about priority/fifo order? Does it lose its place in line? - mutex->waitingThreads.erase(std::remove(mutex->waitingThreads.begin(), mutex->waitingThreads.end(), threadID), mutex->waitingThreads.end()); - - DEBUG_LOG(HLE, "sceKernelLockMutexCB: Suspending lock wait for callback"); - } + auto result = HLEKernel::WaitBeginCallback(threadID, prevCallbackId, mutexWaitTimer); + if (result == HLEKernel::WAIT_CB_SUCCESS) + DEBUG_LOG(HLE, "sceKernelLockMutexCB: Suspending lock wait for callback") else WARN_LOG_REPORT(HLE, "sceKernelLockMutexCB: beginning callback with bad wait id?"); } void __KernelMutexEndCallback(SceUID threadID, SceUID prevCallbackId) { - SceUID pauseKey = prevCallbackId == 0 ? threadID : prevCallbackId; - - u32 error; - SceUID mutexID = __KernelGetWaitID(threadID, WAITTYPE_MUTEX, error); - u32 timeoutPtr = __KernelGetWaitTimeoutPtr(threadID, error); - Mutex *mutex = mutexID == 0 ? NULL : kernelObjects.Get(mutexID, error); - if (!mutex || mutex->pausedWaitTimeouts.find(pauseKey) == mutex->pausedWaitTimeouts.end()) - { - // TODO: Since it was deleted, we don't know how long was actually left. - // For now, we just say the full time was taken. - if (timeoutPtr != 0 && mutexWaitTimer != -1) - Memory::Write_U32(0, timeoutPtr); - - __KernelResumeThreadFromWait(threadID, SCE_KERNEL_ERROR_WAIT_DELETE); - return; - } - - u64 waitDeadline = mutex->pausedWaitTimeouts[pauseKey]; - mutex->pausedWaitTimeouts.erase(pauseKey); - - // TODO: Don't wake up if __KernelCurHasReadyCallbacks()? - - // Attempt to unlock. - if (mutex->nm.lockThread == -1 && __KernelUnlockMutexForThread(mutex, threadID, error, 0)) - return; - - // We only check if it timed out if it couldn't unlock. - s64 cyclesLeft = waitDeadline - CoreTiming::GetTicks(); - if (cyclesLeft < 0 && waitDeadline != 0) - { - if (timeoutPtr != 0 && mutexWaitTimer != -1) - Memory::Write_U32(0, timeoutPtr); - - __KernelResumeThreadFromWait(threadID, SCE_KERNEL_ERROR_WAIT_TIMEOUT); - } - else - { - if (timeoutPtr != 0 && mutexWaitTimer != -1) - CoreTiming::ScheduleEvent(cyclesLeft, mutexWaitTimer, __KernelGetCurThread()); - - // TODO: Should this not go at the end? - mutex->waitingThreads.push_back(threadID); - + auto result = HLEKernel::WaitEndCallback(threadID, prevCallbackId, mutexWaitTimer, __KernelUnlockMutexForThreadCheck); + if (result == HLEKernel::WAIT_CB_RESUMED_WAIT) DEBUG_LOG(HLE, "sceKernelLockMutexCB: Resuming lock wait for callback"); - } } int sceKernelCreateMutex(const char *name, u32 attr, int initialCount, u32 optionsPtr) @@ -996,85 +939,27 @@ void __KernelWaitLwMutex(LwMutex *mutex, u32 timeoutPtr) CoreTiming::ScheduleEvent(usToCycles(micro), lwMutexWaitTimer, __KernelGetCurThread()); } +bool __KernelUnlockLwMutexForThreadCheck(LwMutex *mutex, SceUID threadID, u32 &error, int result, bool &wokeThreads) +{ + if (mutex->nm.lockThread == -1 && __KernelUnlockLwMutexForThread(mutex, mutex->nm.workarea, threadID, error, 0)) + return true; + return false; +} + void __KernelLwMutexBeginCallback(SceUID threadID, SceUID prevCallbackId) { - SceUID pauseKey = prevCallbackId == 0 ? threadID : prevCallbackId; - - u32 error; - SceUID mutexID = __KernelGetWaitID(threadID, WAITTYPE_LWMUTEX, error); - u32 timeoutPtr = __KernelGetWaitTimeoutPtr(threadID, error); - LwMutex *mutex = mutexID == 0 ? NULL : kernelObjects.Get(mutexID, error); - if (mutex) - { - // This means two callbacks in a row. PSP crashes if the same callback runs inside itself. - // TODO: Handle this better? - if (mutex->pausedWaitTimeouts.find(pauseKey) != mutex->pausedWaitTimeouts.end()) - return; - - if (timeoutPtr != 0 && lwMutexWaitTimer != -1) - { - s64 cyclesLeft = CoreTiming::UnscheduleEvent(lwMutexWaitTimer, threadID); - mutex->pausedWaitTimeouts[pauseKey] = CoreTiming::GetTicks() + cyclesLeft; - } - else - mutex->pausedWaitTimeouts[pauseKey] = 0; - - // TODO: Hmm, what about priority/fifo order? Does it lose its place in line? - mutex->waitingThreads.erase(std::remove(mutex->waitingThreads.begin(), mutex->waitingThreads.end(), threadID), mutex->waitingThreads.end()); - - DEBUG_LOG(HLE, "sceKernelLockLwMutexCB: Suspending lock wait for callback"); - } + auto result = HLEKernel::WaitBeginCallback(threadID, prevCallbackId, lwMutexWaitTimer); + if (result == HLEKernel::WAIT_CB_SUCCESS) + DEBUG_LOG(HLE, "sceKernelLockLwMutexCB: Suspending lock wait for callback") else WARN_LOG_REPORT(HLE, "sceKernelLockLwMutexCB: beginning callback with bad wait id?"); } void __KernelLwMutexEndCallback(SceUID threadID, SceUID prevCallbackId) { - SceUID pauseKey = prevCallbackId == 0 ? threadID : prevCallbackId; - - u32 error; - SceUID mutexID = __KernelGetWaitID(threadID, WAITTYPE_LWMUTEX, error); - u32 timeoutPtr = __KernelGetWaitTimeoutPtr(threadID, error); - LwMutex *mutex = mutexID == 0 ? NULL : kernelObjects.Get(mutexID, error); - if (!mutex || mutex->pausedWaitTimeouts.find(pauseKey) == mutex->pausedWaitTimeouts.end()) - { - // TODO: Since it was deleted, we don't know how long was actually left. - // For now, we just say the full time was taken. - if (timeoutPtr != 0 && lwMutexWaitTimer != -1) - Memory::Write_U32(0, timeoutPtr); - - __KernelResumeThreadFromWait(threadID, SCE_KERNEL_ERROR_WAIT_DELETE); - return; - } - - u64 waitDeadline = mutex->pausedWaitTimeouts[pauseKey]; - mutex->pausedWaitTimeouts.erase(pauseKey); - - // TODO: Don't wake up if __KernelCurHasReadyCallbacks()? - - // Attempt to unlock. - if (mutex->nm.lockThread == -1 && __KernelUnlockLwMutexForThread(mutex, mutex->nm.workarea, threadID, error, 0)) - return; - - // We only check if it timed out if it couldn't unlock. - s64 cyclesLeft = waitDeadline - CoreTiming::GetTicks(); - if (cyclesLeft < 0 && waitDeadline != 0) - { - if (timeoutPtr != 0 && lwMutexWaitTimer != -1) - Memory::Write_U32(0, timeoutPtr); - - __KernelResumeThreadFromWait(threadID, SCE_KERNEL_ERROR_WAIT_TIMEOUT); - } - else - { - if (timeoutPtr != 0 && lwMutexWaitTimer != -1) - CoreTiming::ScheduleEvent(cyclesLeft, lwMutexWaitTimer, __KernelGetCurThread()); - - // TODO: Should this not go at the end? - mutex->waitingThreads.push_back(threadID); - + auto result = HLEKernel::WaitEndCallback(threadID, prevCallbackId, lwMutexWaitTimer, __KernelUnlockLwMutexForThreadCheck); + if (result == HLEKernel::WAIT_CB_RESUMED_WAIT) DEBUG_LOG(HLE, "sceKernelLockLwMutexCB: Resuming lock wait for callback"); - } } int sceKernelTryLockLwMutex(u32 workareaPtr, int count) diff --git a/Core/HLE/sceKernelSemaphore.cpp b/Core/HLE/sceKernelSemaphore.cpp index 5060d3e024..307b11c79b 100644 --- a/Core/HLE/sceKernelSemaphore.cpp +++ b/Core/HLE/sceKernelSemaphore.cpp @@ -24,6 +24,7 @@ #include "Core/HLE/sceKernel.h" #include "Core/HLE/sceKernelThread.h" #include "Core/HLE/sceKernelSemaphore.h" +#include "Core/HLE/KernelWaitHelpers.h" #define PSP_SEMA_ATTR_FIFO 0 #define PSP_SEMA_ATTR_PRIORITY 0x100 @@ -65,14 +66,14 @@ struct Semaphore : public KernelObject p.Do(ns); SceUID dv = 0; p.Do(waitingThreads, dv); - p.Do(pausedWaitTimeouts); + p.Do(pausedWaits); p.DoMarker("Semaphore"); } NativeSemaphore ns; std::vector waitingThreads; // Key is the callback id it was for, or if no callback, the thread id. - std::map pausedWaitTimeouts; + std::map pausedWaits; }; static int semaWaitTimer = -1; @@ -134,86 +135,18 @@ bool __KernelUnlockSemaForThread(Semaphore *s, SceUID threadID, u32 &error, int void __KernelSemaBeginCallback(SceUID threadID, SceUID prevCallbackId) { - SceUID pauseKey = prevCallbackId == 0 ? threadID : prevCallbackId; - - u32 error; - SceUID semaID = __KernelGetWaitID(threadID, WAITTYPE_SEMA, error); - u32 timeoutPtr = __KernelGetWaitTimeoutPtr(threadID, error); - Semaphore *s = semaID == 0 ? NULL : kernelObjects.Get(semaID, error); - if (s) - { - // This means two callbacks in a row. PSP crashes if the same callback runs inside itself. - // TODO: Handle this better? - if (s->pausedWaitTimeouts.find(pauseKey) != s->pausedWaitTimeouts.end()) - return; - - if (timeoutPtr != 0 && semaWaitTimer != -1) - { - s64 cyclesLeft = CoreTiming::UnscheduleEvent(semaWaitTimer, threadID); - s->pausedWaitTimeouts[pauseKey] = CoreTiming::GetTicks() + cyclesLeft; - } - else - s->pausedWaitTimeouts[pauseKey] = 0; - - // TODO: Hmm, what about priority/fifo order? Does it lose its place in line? - s->waitingThreads.erase(std::remove(s->waitingThreads.begin(), s->waitingThreads.end(), threadID), s->waitingThreads.end()); - - DEBUG_LOG(HLE, "sceKernelWaitSemaCB: Suspending sema wait for callback"); - } + auto result = HLEKernel::WaitBeginCallback(threadID, prevCallbackId, semaWaitTimer); + if (result == HLEKernel::WAIT_CB_SUCCESS) + DEBUG_LOG(HLE, "sceKernelWaitSemaCB: Suspending sema wait for callback") else WARN_LOG_REPORT(HLE, "sceKernelWaitSemaCB: beginning callback with bad wait id?"); } void __KernelSemaEndCallback(SceUID threadID, SceUID prevCallbackId) { - SceUID pauseKey = prevCallbackId == 0 ? threadID : prevCallbackId; - - // Note: Cancel does not affect suspended semaphore waits. - - u32 error; - SceUID semaID = __KernelGetWaitID(threadID, WAITTYPE_SEMA, error); - u32 timeoutPtr = __KernelGetWaitTimeoutPtr(threadID, error); - Semaphore *s = semaID == 0 ? NULL : kernelObjects.Get(semaID, error); - if (!s || s->pausedWaitTimeouts.find(pauseKey) == s->pausedWaitTimeouts.end()) - { - // TODO: Since it was deleted, we don't know how long was actually left. - // For now, we just say the full time was taken. - if (timeoutPtr != 0 && semaWaitTimer != -1) - Memory::Write_U32(0, timeoutPtr); - - __KernelResumeThreadFromWait(threadID, SCE_KERNEL_ERROR_WAIT_DELETE); - return; - } - - u64 waitDeadline = s->pausedWaitTimeouts[pauseKey]; - s->pausedWaitTimeouts.erase(pauseKey); - - // TODO: Don't wake up if __KernelCurHasReadyCallbacks()? - - bool wokeThreads; - // Attempt to unlock. - if (__KernelUnlockSemaForThread(s, threadID, error, 0, wokeThreads)) - return; - - // We only check if it timed out if it couldn't unlock. - s64 cyclesLeft = waitDeadline - CoreTiming::GetTicks(); - if (cyclesLeft < 0 && waitDeadline != 0) - { - if (timeoutPtr != 0 && semaWaitTimer != -1) - Memory::Write_U32(0, timeoutPtr); - - __KernelResumeThreadFromWait(threadID, SCE_KERNEL_ERROR_WAIT_TIMEOUT); - } - else - { - if (timeoutPtr != 0 && semaWaitTimer != -1) - CoreTiming::ScheduleEvent(cyclesLeft, semaWaitTimer, __KernelGetCurThread()); - - // TODO: Should this not go at the end? - s->waitingThreads.push_back(threadID); - + auto result = HLEKernel::WaitEndCallback(threadID, prevCallbackId, semaWaitTimer, __KernelUnlockSemaForThread); + if (result == HLEKernel::WAIT_CB_RESUMED_WAIT) DEBUG_LOG(HLE, "sceKernelWaitSemaCB: Resuming sema wait for callback"); - } } // Resume all waiting threads (for delete / cancel.) diff --git a/Core/HLE/sceKernelThread.cpp b/Core/HLE/sceKernelThread.cpp index 2a7d71d6c3..0a5959bb3d 100644 --- a/Core/HLE/sceKernelThread.cpp +++ b/Core/HLE/sceKernelThread.cpp @@ -22,22 +22,23 @@ #include "Common/LogManager.h" #include "Common/CommonTypes.h" -#include "HLE.h" -#include "HLETables.h" -#include "../MIPS/MIPSInt.h" -#include "../MIPS/MIPSCodeUtils.h" -#include "../MIPS/MIPS.h" +#include "Core/HLE/HLE.h" +#include "Core/HLE/HLETables.h" +#include "Core/MIPS/MIPSInt.h" +#include "Core/MIPS/MIPSCodeUtils.h" +#include "Core/MIPS/MIPS.h" #include "Core/CoreTiming.h" #include "Core/MemMap.h" #include "Core/Reporting.h" -#include "ChunkFile.h" +#include "Common/ChunkFile.h" -#include "sceAudio.h" -#include "sceKernel.h" -#include "sceKernelMemory.h" -#include "sceKernelThread.h" -#include "sceKernelModule.h" -#include "sceKernelInterrupt.h" +#include "Core/HLE/sceAudio.h" +#include "Core/HLE/sceKernel.h" +#include "Core/HLE/sceKernelMemory.h" +#include "Core/HLE/sceKernelThread.h" +#include "Core/HLE/sceKernelModule.h" +#include "Core/HLE/sceKernelInterrupt.h" +#include "Core/HLE/KernelWaitHelpers.h" typedef struct { @@ -924,14 +925,9 @@ void __KernelDelayBeginCallback(SceUID threadID, SceUID prevCallbackId) { u32 error; SceUID waitID = __KernelGetWaitID(threadID, WAITTYPE_DELAY, error); if (waitID == threadID) { - // This means two callbacks in a row. PSP crashes if the same callback runs inside itself. - // TODO: Handle this better? - if (pausedDelays.find(pauseKey) != pausedDelays.end()) - return; - - s64 cyclesLeft = CoreTiming::UnscheduleEvent(eventScheduledWakeup, threadID); - pausedDelays[pauseKey] = CoreTiming::GetTicks() + cyclesLeft; - + // Most waits need to keep track of waiting threads, delays don't. Use a fake list. + std::vector dummy; + HLEKernel::WaitBeginCallback(threadID, prevCallbackId, eventScheduledWakeup, dummy, pausedDelays, true); DEBUG_LOG(HLE, "sceKernelDelayThreadCB: Suspending delay for callback"); } else diff --git a/Core/HLE/sceKernelThread.h b/Core/HLE/sceKernelThread.h index 8f723b3cc7..dd022abda2 100644 --- a/Core/HLE/sceKernelThread.h +++ b/Core/HLE/sceKernelThread.h @@ -333,4 +333,4 @@ struct DebugThreadInfo std::vector GetThreadsInfo(); void __KernelChangeThreadState(SceUID threadId, ThreadStatus newStatus); -int hleLoadExecForUser_362A956B(); \ No newline at end of file +int hleLoadExecForUser_362A956B(); From 4ac0f7a34529f800f13d9ca31dc62d43dd3bdcbd Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Mon, 27 May 2013 14:09:38 -0700 Subject: [PATCH 7/7] Handle it better when umd waits trigger during cbs. --- Core/HLE/sceUmd.cpp | 112 +++++++++++++++++++++++++++++++++++--------- 1 file changed, 89 insertions(+), 23 deletions(-) diff --git a/Core/HLE/sceUmd.cpp b/Core/HLE/sceUmd.cpp index a954d57327..f9e8873609 100644 --- a/Core/HLE/sceUmd.cpp +++ b/Core/HLE/sceUmd.cpp @@ -19,33 +19,21 @@ #include "Core/HLE/HLE.h" #include "Core/MIPS/MIPS.h" #include "Core/CoreTiming.h" +#include "Core/Reporting.h" #include "Core/HLE/sceUmd.h" #include "Core/HLE/sceKernelThread.h" #include "Core/HLE/sceKernelInterrupt.h" const u64 MICRO_DELAY_ACTIVATE = 4000; -struct UmdWaitingThread -{ - SceUID threadID; - u32 stat; - - inline static UmdWaitingThread Make(SceUID threadID, u32 stat) - { - UmdWaitingThread th; - th.threadID = threadID; - th.stat = stat; - return th; - } -}; - static u8 umdActivated = 1; static u32 umdStatus = 0; static u32 umdErrorStat = 0; static int driveCBId = -1; static int umdStatTimeoutEvent = -1; static int umdStatChangeEvent = -1; -static std::vector umdWaitingThreads; +static std::vector umdWaitingThreads; +static std::map umdPausedWaitTimeouts; struct PspUmdInfo { u32_le size; @@ -54,6 +42,8 @@ struct PspUmdInfo { void __UmdStatTimeout(u64 userdata, int cyclesLate); void __UmdStatChange(u64 userdata, int cyclesLate); +void __UmdBeginCallback(SceUID threadID, SceUID prevCallbackId); +void __UmdEndCallback(SceUID threadID, SceUID prevCallbackId); void __UmdInit() { @@ -63,6 +53,8 @@ void __UmdInit() umdStatus = 0; umdErrorStat = 0; driveCBId = -1; + + __KernelRegisterWaitTypeFuncs(WAITTYPE_UMD, __UmdBeginCallback, __UmdEndCallback); } void __UmdDoState(PointerWrap &p) @@ -76,6 +68,7 @@ void __UmdDoState(PointerWrap &p) p.Do(umdStatChangeEvent); CoreTiming::RestoreRegisterEvent(umdStatChangeEvent, "UmdChange", __UmdStatChange); p.Do(umdWaitingThreads); + p.Do(umdPausedWaitTimeouts); p.DoMarker("sceUmd"); } @@ -99,14 +92,15 @@ void __UmdStatChange(u64 userdata, int cyclesLate) // Wake anyone waiting on this. for (size_t i = 0; i < umdWaitingThreads.size(); ++i) { - UmdWaitingThread &info = umdWaitingThreads[i]; + SceUID threadID = umdWaitingThreads[i]; u32 error; - SceUID waitID = __KernelGetWaitID(info.threadID, WAITTYPE_UMD, error); + SceUID waitID = __KernelGetWaitID(threadID, WAITTYPE_UMD, error); + u32 stat = __KernelGetWaitValue(threadID, error); bool keep = false; if (waitID == 1) { - if ((info.stat & __KernelUmdGetState()) != 0) - __KernelResumeThreadFromWait(info.threadID, 0); + if ((stat & __KernelUmdGetState()) != 0) + __KernelResumeThreadFromWait(threadID, 0); // Only if they are still waiting do we keep them in the list. else keep = true; @@ -136,6 +130,78 @@ void __KernelUmdDeactivate() __UmdStatChange(0, 0); } +void __UmdBeginCallback(SceUID threadID, SceUID prevCallbackId) +{ + SceUID pauseKey = prevCallbackId == 0 ? threadID : prevCallbackId; + + u32 error; + SceUID waitID = __KernelGetWaitID(threadID, WAITTYPE_UMD, error); + if (waitID == 1) + { + // This means two callbacks in a row. PSP crashes if the same callback runs inside itself. + // TODO: Handle this better? + if (umdPausedWaitTimeouts.find(pauseKey) != umdPausedWaitTimeouts.end()) + return; + + _dbg_assert_msg_(HLE, umdStatTimeoutEvent != -1, "Must have a umd timer"); + s64 cyclesLeft = CoreTiming::UnscheduleEvent(umdStatTimeoutEvent, threadID); + if (cyclesLeft != 0) + umdPausedWaitTimeouts[pauseKey] = CoreTiming::GetTicks() + cyclesLeft; + else + umdPausedWaitTimeouts[pauseKey] = 0; + + for (auto it = umdWaitingThreads.begin(); it < umdWaitingThreads.end(); ++it) + { + if (threadID == threadID) + umdWaitingThreads.erase(it--); + } + + DEBUG_LOG(HLE, "sceUmdWaitDriveStatCB: Suspending lock wait for callback"); + } + else + WARN_LOG_REPORT(HLE, "sceUmdWaitDriveStatCB: beginning callback with bad wait id?"); +} + +void __UmdEndCallback(SceUID threadID, SceUID prevCallbackId) +{ + SceUID pauseKey = prevCallbackId == 0 ? threadID : prevCallbackId; + + u32 error; + SceUID waitID = __KernelGetWaitID(threadID, WAITTYPE_UMD, error); + u32 stat = __KernelGetWaitValue(threadID, error); + if (umdPausedWaitTimeouts.find(pauseKey) == umdPausedWaitTimeouts.end()) + { + WARN_LOG_REPORT(HLE, "__UmdEndCallback(): UMD paused wait missing"); + + __KernelResumeThreadFromWait(threadID, 0); + return; + } + + u64 waitDeadline = umdPausedWaitTimeouts[pauseKey]; + umdPausedWaitTimeouts.erase(pauseKey); + + // TODO: Don't wake up if __KernelCurHasReadyCallbacks()? + + if ((stat & __KernelUmdGetState()) != 0) + { + __KernelResumeThreadFromWait(threadID, 0); + return; + } + + s64 cyclesLeft = waitDeadline - CoreTiming::GetTicks(); + if (cyclesLeft < 0 && waitDeadline != 0) + __KernelResumeThreadFromWait(threadID, SCE_KERNEL_ERROR_WAIT_TIMEOUT); + else + { + _dbg_assert_msg_(HLE, umdStatTimeoutEvent != -1, "Must have a umd timer"); + CoreTiming::ScheduleEvent(cyclesLeft, umdStatTimeoutEvent, __KernelGetCurThread()); + + umdWaitingThreads.push_back(threadID); + + DEBUG_LOG(HLE, "sceUmdWaitDriveStatCB: Resuming lock wait for callback"); + } +} + int sceUmdCheckMedium() { DEBUG_LOG(HLE, "1=sceUmdCheckMedium()"); @@ -246,7 +312,7 @@ void __UmdStatTimeout(u64 userdata, int cyclesLate) __KernelResumeThreadFromWait(threadID, SCE_KERNEL_ERROR_WAIT_TIMEOUT); for (size_t i = 0; i < umdWaitingThreads.size(); ++i) { - if (umdWaitingThreads[i].threadID == threadID) + if (umdWaitingThreads[i] == threadID) umdWaitingThreads.erase(umdWaitingThreads.begin() + i--); } } @@ -287,7 +353,7 @@ int sceUmdWaitDriveStat(u32 stat) if ((stat & __KernelUmdGetState()) == 0) { DEBUG_LOG(HLE, "sceUmdWaitDriveStat(stat = %08x): waiting", stat); - umdWaitingThreads.push_back(UmdWaitingThread::Make(__KernelGetCurThread(), stat)); + umdWaitingThreads.push_back(__KernelGetCurThread()); __KernelWaitCurThread(WAITTYPE_UMD, 1, stat, 0, 0, "umd stat waited"); return 0; } @@ -315,7 +381,7 @@ int sceUmdWaitDriveStatWithTimer(u32 stat, u32 timeout) if ((stat & __KernelUmdGetState()) == 0) { DEBUG_LOG(HLE, "sceUmdWaitDriveStatWithTimer(stat = %08x, timeout = %d): waiting", stat, timeout); __UmdWaitStat(timeout); - umdWaitingThreads.push_back(UmdWaitingThread::Make(__KernelGetCurThread(), stat)); + umdWaitingThreads.push_back(__KernelGetCurThread()); __KernelWaitCurThread(WAITTYPE_UMD, 1, stat, 0, 0, "umd stat waited with timer"); return 0; } else { @@ -350,7 +416,7 @@ int sceUmdWaitDriveStatCB(u32 stat, u32 timeout) } __UmdWaitStat(timeout); - umdWaitingThreads.push_back(UmdWaitingThread::Make(__KernelGetCurThread(), stat)); + umdWaitingThreads.push_back(__KernelGetCurThread()); __KernelWaitCurThread(WAITTYPE_UMD, 1, stat, 0, true, "umd stat waited"); } else { hleReSchedule("umd stat waited");