mirror of
https://github.com/hrydgard/ppsspp.git
synced 2026-11-18 11:54:30 +01:00
Merge pull request #3583 from unknownbrackets/callbacks
Callback and minor scheduling fixes
This commit is contained in:
commit
361a6eaf63
12 files changed
+599
-403
No files matched your search
@@ -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
|
||||
|
||||
@@ -429,6 +429,7 @@
|
||||
<ClInclude Include="HLE\FunctionWrappers.h" />
|
||||
<ClInclude Include="HLE\HLE.h" />
|
||||
<ClInclude Include="HLE\HLETables.h" />
|
||||
<ClInclude Include="HLE\KernelWaitHelpers.h" />
|
||||
<ClInclude Include="HLE\sceAtrac.h" />
|
||||
<ClInclude Include="HLE\sceAudio.h" />
|
||||
<ClInclude Include="HLE\sceAudiocodec.h" />
|
||||
|
||||
@@ -891,6 +891,9 @@
|
||||
<ClInclude Include="MIPS\PPC\PpcRegCache.h">
|
||||
<Filter>MIPS\PPC</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="HLE\KernelWaitHelpers.h">
|
||||
<Filter>HLE\Kernel</Filter>
|
||||
</ClInclude>
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<None Include="CMakeLists.txt" />
|
||||
|
||||
@@ -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 <vector>
|
||||
#include <map>
|
||||
#include <algorithm>
|
||||
#include "Core/HLE/sceKernelThread.h"
|
||||
|
||||
namespace HLEKernel
|
||||
{
|
||||
|
||||
template <typename WaitInfoType, typename PauseType>
|
||||
inline bool WaitPauseHelperUpdate(SceUID pauseKey, SceUID threadID, std::vector<WaitInfoType> &waitingThreads, std::map<SceUID, PauseType> &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, u64>(SceUID pauseKey, SceUID threadID, std::vector<SceUID> &waitingThreads, std::map<SceUID, u64> &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 <typename WaitInfoType, typename PauseType>
|
||||
inline u64 WaitPauseHelperGet(SceUID pauseKey, SceUID threadID, std::map<SceUID, PauseType> &pausedWaits, WaitInfoType &waitData) {
|
||||
waitData = pausedWaits[pauseKey];
|
||||
u64 waitDeadline = waitData.pausedTimeout;
|
||||
pausedWaits.erase(pauseKey);
|
||||
return waitDeadline;
|
||||
}
|
||||
|
||||
template <>
|
||||
inline u64 WaitPauseHelperGet<SceUID, u64>(SceUID pauseKey, SceUID threadID, std::map<SceUID, u64> &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 <typename WaitInfoType, typename PauseType>
|
||||
WaitBeginEndCallbackResult WaitBeginCallback(SceUID threadID, SceUID prevCallbackId, int waitTimer, std::vector<WaitInfoType> &waitingThreads, std::map<SceUID, PauseType> &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 <typename KO, WaitType waitType, typename WaitInfoType>
|
||||
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<KO>(uid, error);
|
||||
if (ko) {
|
||||
return WaitBeginCallback(threadID, prevCallbackId, waitTimer, ko->waitingThreads, ko->pausedWaits, timeoutPtr != 0);
|
||||
} else {
|
||||
return WAIT_CB_BAD_WAIT_ID;
|
||||
}
|
||||
}
|
||||
|
||||
template <typename KO, WaitType waitType, typename WaitInfoType, typename PauseType, class TryUnlockFunc>
|
||||
WaitBeginEndCallbackResult WaitEndCallback(SceUID threadID, SceUID prevCallbackId, int waitTimer, TryUnlockFunc TryUnlock, std::vector<WaitInfoType> &waitingThreads, std::map<SceUID, PauseType> &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<KO>(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 <typename KO, WaitType waitType, typename WaitInfoType, class TryUnlockFunc>
|
||||
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<KO>(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<KO, waitType>(threadID, prevCallbackId, waitTimer, TryUnlock, ko->waitingThreads, ko->pausedWaits);
|
||||
}
|
||||
|
||||
};
|
||||
+20
-102
@@ -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;
|
||||
@@ -108,7 +109,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()
|
||||
{
|
||||
@@ -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,103 +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<EventFlag>(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<EventFlag, WAITTYPE_EVENTFLAG, EventFlagTh>(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, u32 &returnValue)
|
||||
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<EventFlag>(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<EventFlag, WAITTYPE_EVENTFLAG, EventFlagTh>(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);
|
||||
@@ -449,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;
|
||||
|
||||
@@ -486,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;
|
||||
@@ -539,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.
|
||||
@@ -614,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.
|
||||
@@ -708,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--);
|
||||
|
||||
+63
-16
@@ -15,13 +15,16 @@
|
||||
// Official git repository and contact information can be found at
|
||||
// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/.
|
||||
|
||||
#include "sceKernel.h"
|
||||
#include "sceKernelThread.h"
|
||||
#include "sceKernelMbx.h"
|
||||
#include "HLE.h"
|
||||
#include <map>
|
||||
#include <vector>
|
||||
#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
|
||||
@@ -31,8 +34,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 +67,7 @@ struct Mbx : public KernelObject
|
||||
{
|
||||
for (std::vector<MbxWaitingThread>::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 +173,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<MbxWaitingThread> waitingThreads;
|
||||
// Key is the callback id it was for, or if no callback, the thread id.
|
||||
std::map<SceUID, MbxWaitingThread> pausedWaits;
|
||||
};
|
||||
|
||||
void __KernelMbxBeginCallback(SceUID threadID, SceUID prevCallbackId);
|
||||
void __KernelMbxEndCallback(SceUID threadID, SceUID prevCallbackId);
|
||||
|
||||
void __KernelMbxInit()
|
||||
{
|
||||
mbxWaitTimer = CoreTiming::RegisterEvent("MbxTimeout", __KernelMbxTimeout);
|
||||
__KernelRegisterWaitTypeFuncs(WAITTYPE_MBX, __KernelMbxBeginCallback, __KernelMbxEndCallback);
|
||||
}
|
||||
|
||||
void __KernelMbxDoState(PointerWrap &p)
|
||||
@@ -196,8 +207,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 +217,43 @@ 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;
|
||||
}
|
||||
|
||||
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)
|
||||
{
|
||||
auto result = HLEKernel::WaitBeginCallback<Mbx, WAITTYPE_SEMA, MbxWaitingThread>(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)
|
||||
{
|
||||
auto result = HLEKernel::WaitEndCallback<Mbx, WAITTYPE_SEMA, MbxWaitingThread>(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)
|
||||
{
|
||||
SceUID threadID = (SceUID)userdata;
|
||||
@@ -260,7 +299,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 +315,7 @@ std::vector<MbxWaitingThread>::iterator __KernelMbxFindPriority(std::vector<MbxW
|
||||
u32 best_prio = 0xFFFFFFFF;
|
||||
for (iter = waiting.begin(), end = waiting.end(); iter != end; ++iter)
|
||||
{
|
||||
u32 iter_prio = __KernelGetThreadPrio(iter->first);
|
||||
u32 iter_prio = __KernelGetThreadPrio(iter->threadID);
|
||||
if (iter_prio < best_prio)
|
||||
{
|
||||
best = iter;
|
||||
@@ -386,8 +425,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 +603,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)
|
||||
{
|
||||
|
||||
@@ -17,6 +17,8 @@
|
||||
|
||||
#include <algorithm>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <map>
|
||||
#include "Core/HLE/HLE.h"
|
||||
#include "Core/System.h"
|
||||
#include "Core/MIPS/MIPS.h"
|
||||
@@ -28,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;
|
||||
|
||||
@@ -53,6 +56,7 @@ struct FplWaitingThread
|
||||
{
|
||||
SceUID threadID;
|
||||
u32 addrPtr;
|
||||
u64 pausedTimeout;
|
||||
};
|
||||
|
||||
struct NativeFPL
|
||||
@@ -118,6 +122,7 @@ struct FPL : public KernelObject
|
||||
p.Do(nextBlock);
|
||||
FplWaitingThread dv = {0};
|
||||
p.Do(waitingThreads, dv);
|
||||
p.Do(pausedWaits);
|
||||
p.DoMarker("FPL");
|
||||
}
|
||||
|
||||
@@ -127,12 +132,15 @@ struct FPL : public KernelObject
|
||||
int alignedSize;
|
||||
int nextBlock;
|
||||
std::vector<FplWaitingThread> waitingThreads;
|
||||
// Key is the callback id it was for, or if no callback, the thread id.
|
||||
std::map<SceUID, FplWaitingThread> pausedWaits;
|
||||
};
|
||||
|
||||
struct VplWaitingThread
|
||||
{
|
||||
SceUID threadID;
|
||||
u32 addrPtr;
|
||||
u64 pausedTimeout;
|
||||
};
|
||||
|
||||
struct SceKernelVplInfo
|
||||
@@ -162,18 +170,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<VplWaitingThread> waitingThreads;
|
||||
// Key is the callback id it was for, or if no callback, the thread id.
|
||||
std::map<SceUID, VplWaitingThread> 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 +203,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 +277,24 @@ bool __KernelUnlockFplForThread(FPL *fpl, FplWaitingThread &threadInfo, u32 &err
|
||||
return true;
|
||||
}
|
||||
|
||||
void __KernelFplBeginCallback(SceUID threadID, SceUID prevCallbackId)
|
||||
{
|
||||
auto result = HLEKernel::WaitBeginCallback<FPL, WAITTYPE_FPL, FplWaitingThread>(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)
|
||||
{
|
||||
auto result = HLEKernel::WaitEndCallback<FPL, WAITTYPE_FPL, FplWaitingThread>(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)
|
||||
{
|
||||
for (size_t i = 0; i < fpl->waitingThreads.size(); i++)
|
||||
@@ -1147,6 +1184,24 @@ bool __KernelUnlockVplForThread(VPL *vpl, VplWaitingThread &threadInfo, u32 &err
|
||||
return true;
|
||||
}
|
||||
|
||||
void __KernelVplBeginCallback(SceUID threadID, SceUID prevCallbackId)
|
||||
{
|
||||
auto result = HLEKernel::WaitBeginCallback<VPL, WAITTYPE_VPL, VplWaitingThread>(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)
|
||||
{
|
||||
auto result = HLEKernel::WaitEndCallback<VPL, WAITTYPE_VPL, VplWaitingThread>(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)
|
||||
{
|
||||
for (size_t i = 0; i < vpl->waitingThreads.size(); i++)
|
||||
|
||||
+39
-154
@@ -17,14 +17,15 @@
|
||||
|
||||
#include <algorithm>
|
||||
#include <map>
|
||||
#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<SceUID> waitingThreads;
|
||||
// Key is the callback id it was for, or if no callback, the thread id.
|
||||
std::map<SceUID, u64> pausedWaitTimeouts;
|
||||
std::map<SceUID, u64> 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<SceUID> waitingThreads;
|
||||
// Key is the callback id it was for, or if no callback, the thread id.
|
||||
std::map<SceUID, u64> pausedWaitTimeouts;
|
||||
std::map<SceUID, u64> pausedWaits;
|
||||
};
|
||||
|
||||
static int mutexWaitTimer = -1;
|
||||
@@ -151,9 +152,9 @@ typedef std::multimap<SceUID, SceUID> 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()
|
||||
{
|
||||
@@ -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<Mutex>(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<Mutex, WAITTYPE_MUTEX, SceUID>(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, u32 &returnValue)
|
||||
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<Mutex>(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<Mutex, WAITTYPE_MUTEX, SceUID>(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<LwMutex>(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<LwMutex, WAITTYPE_LWMUTEX, SceUID>(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, u32 &returnValue)
|
||||
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<LwMutex>(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<LwMutex, WAITTYPE_LWMUTEX, SceUID>(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)
|
||||
|
||||
@@ -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,20 +66,20 @@ 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<SceUID> waitingThreads;
|
||||
// Key is the callback id it was for, or if no callback, the thread id.
|
||||
std::map<SceUID, u64> pausedWaitTimeouts;
|
||||
std::map<SceUID, u64> pausedWaits;
|
||||
};
|
||||
|
||||
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()
|
||||
{
|
||||
@@ -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<Semaphore>(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<Semaphore, WAITTYPE_SEMA, SceUID>(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, u32 &returnValue)
|
||||
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<Semaphore>(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<Semaphore, WAITTYPE_SEMA, SceUID>(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.)
|
||||
|
||||
+128
-29
@@ -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
|
||||
{
|
||||
@@ -158,7 +159,22 @@ typedef WaitType WaitType_le;
|
||||
typedef swap_struct_t<WaitType, swap_32_t<WaitType> > 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 +190,7 @@ struct NativeThread
|
||||
|
||||
s32_le initialPriority;
|
||||
s32_le currentPriority;
|
||||
WaitType waitType;
|
||||
WaitType_le waitType;
|
||||
SceUID_le waitID;
|
||||
s32_le wakeupCount;
|
||||
s32_le exitStatus;
|
||||
@@ -820,6 +836,9 @@ MipsCallManager mipsCalls;
|
||||
int actionAfterCallback;
|
||||
int actionAfterMipsCall;
|
||||
|
||||
// When inside a callback, delays are "paused", and rechecked after the callback returns.
|
||||
std::map<SceUID, u64> pausedDelays;
|
||||
|
||||
// Doesn't need state saving.
|
||||
WaitTypeFuncs waitTypeFuncs[NUM_WAITTYPES];
|
||||
|
||||
@@ -892,16 +911,80 @@ 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) {
|
||||
// Most waits need to keep track of waiting threads, delays don't. Use a fake list.
|
||||
std::vector<SceUID> dummy;
|
||||
HLEKernel::WaitBeginCallback(threadID, prevCallbackId, eventScheduledWakeup, dummy, pausedDelays, true);
|
||||
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) {
|
||||
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 error;
|
||||
Thread *thread = kernelObjects.Get<Thread>(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 +1081,9 @@ void __KernelThreadingInit()
|
||||
|
||||
__KernelListenThreadEnd(__KernelCancelWakeup);
|
||||
__KernelListenThreadEnd(__KernelCancelThreadEndTimeout);
|
||||
|
||||
__KernelRegisterWaitTypeFuncs(WAITTYPE_DELAY, __KernelDelayBeginCallback, __KernelDelayEndCallback);
|
||||
__KernelRegisterWaitTypeFuncs(WAITTYPE_SLEEP, __KernelSleepBeginCallback, __KernelSleepEndCallback);
|
||||
}
|
||||
|
||||
void __KernelThreadingDoState(PointerWrap &p)
|
||||
@@ -1029,6 +1115,8 @@ void __KernelThreadingDoState(PointerWrap &p)
|
||||
p.Do(actionAfterCallback);
|
||||
__KernelRestoreActionType(actionAfterCallback, ActionAfterCallback::Create);
|
||||
|
||||
p.Do(pausedDelays);
|
||||
|
||||
hleCurrentThreadName = __KernelGetThreadName(currentThread);
|
||||
lastSwitchCycles = CoreTiming::GetTicks();
|
||||
|
||||
@@ -1214,6 +1302,7 @@ void __KernelThreadingShutdown()
|
||||
currentThread = 0;
|
||||
intReturnHackAddr = 0;
|
||||
hleCurrentThreadName = NULL;
|
||||
pausedDelays.clear();
|
||||
}
|
||||
|
||||
const char *__KernelGetThreadName(SceUID threadID)
|
||||
@@ -1347,16 +1436,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<SceKernelThreadRunStatus> 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;
|
||||
}
|
||||
@@ -2473,6 +2566,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<Thread>(uid, error);
|
||||
if (t)
|
||||
@@ -3261,7 +3360,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?
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -333,4 +333,4 @@ struct DebugThreadInfo
|
||||
|
||||
std::vector<DebugThreadInfo> GetThreadsInfo();
|
||||
void __KernelChangeThreadState(SceUID threadId, ThreadStatus newStatus);
|
||||
int hleLoadExecForUser_362A956B();
|
||||
int hleLoadExecForUser_362A956B();
|
||||
+89
-23
@@ -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<UmdWaitingThread> umdWaitingThreads;
|
||||
static std::vector<SceUID> umdWaitingThreads;
|
||||
static std::map<SceUID, u64> 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");
|
||||
|
||||
Reference in new issue
Block a user