From f145bafc7abf42793e3f38fb644e8763d886d968 Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Sun, 9 Dec 2012 00:29:10 -0800 Subject: [PATCH] Wrap a few of the sceKernel*Thread funcs. --- Core/HLE/FunctionWrappers.h | 6 +++ Core/HLE/sceKernel.cpp | 10 ++--- Core/HLE/sceKernelThread.cpp | 73 +++++++++++++++--------------------- Core/HLE/sceKernelThread.h | 10 ++--- 4 files changed, 47 insertions(+), 52 deletions(-) diff --git a/Core/HLE/FunctionWrappers.h b/Core/HLE/FunctionWrappers.h index abb7de402b..bc7f1ed1b2 100644 --- a/Core/HLE/FunctionWrappers.h +++ b/Core/HLE/FunctionWrappers.h @@ -232,6 +232,12 @@ template void WrapI_CUUU() { RETURN(retval); } +template void WrapI_CUUIUU() { + int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2), + PARAM(3), PARAM(4), PARAM(5)); + RETURN(retval); +} + template void WrapU_CU() { u32 retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1)); RETURN((u32) retval); diff --git a/Core/HLE/sceKernel.cpp b/Core/HLE/sceKernel.cpp index 7872b18f39..c86a6d6d70 100644 --- a/Core/HLE/sceKernel.cpp +++ b/Core/HLE/sceKernel.cpp @@ -354,8 +354,8 @@ const HLEFunction ThreadManForUser[] = {0xFCCFAD26,sceKernelCancelWakeupThread,"sceKernelCancelWakeupThread"}, {0xea748e31,sceKernelChangeCurrentThreadAttr,"sceKernelChangeCurrentThreadAttr"}, {0x71bc9871,sceKernelChangeThreadPriority,"sceKernelChangeThreadPriority"}, - {0x446D8DE6,sceKernelCreateThread,"sceKernelCreateThread"}, - {0x9fa03cd3,sceKernelDeleteThread,"sceKernelDeleteThread"}, + {0x446D8DE6,WrapI_CUUIUU,"sceKernelCreateThread"}, + {0x9fa03cd3,WrapI_I,"sceKernelDeleteThread"}, {0xBD123D9E,0,"sceKernelDelaySysClockThread"}, {0x1181E963,0,"sceKernelDelaySysClockThreadCB"}, {0xceadeb47,sceKernelDelayThread,"sceKernelDelayThread"}, @@ -375,10 +375,10 @@ const HLEFunction ThreadManForUser[] = {0x912354a7,sceKernelRotateThreadReadyQueue,"sceKernelRotateThreadReadyQueue"}, {0x9ACE131E,sceKernelSleepThread,"sceKernelSleepThread"}, {0x82826f70,sceKernelSleepThreadCB,"sceKernelSleepThreadCB"}, - {0xF475845D,&WrapV_IUU,"sceKernelStartThread"}, + {0xF475845D,&WrapI_IUU,"sceKernelStartThread"}, {0x9944f31f,sceKernelSuspendThread,"sceKernelSuspendThread"}, - {0x616403ba,WrapV_U,"sceKernelTerminateThread"}, - {0x383f7bcc,sceKernelTerminateDeleteThread,"sceKernelTerminateDeleteThread"}, + {0x616403ba,WrapI_U,"sceKernelTerminateThread"}, + {0x383f7bcc,WrapI_I,"sceKernelTerminateDeleteThread"}, {0x840E8133,sceKernelWaitThreadEndCB,"sceKernelWaitThreadEndCB"}, {0xd13bde95,sceKernelCheckThreadStack,"sceKernelCheckThreadStack"}, diff --git a/Core/HLE/sceKernelThread.cpp b/Core/HLE/sceKernelThread.cpp index 7dc3683825..1f5d969f05 100644 --- a/Core/HLE/sceKernelThread.cpp +++ b/Core/HLE/sceKernelThread.cpp @@ -929,26 +929,19 @@ void __KernelSetupRootThread(SceUID moduleID, int args, const char *argp, int pr } -void sceKernelCreateThread() +int sceKernelCreateThread(const char *threadName, u32 entry, u32 prio, int stacksize, u32 attr, u32 optionAddr) { - u32 nameAddr = PARAM(0); - const char *threadName = Memory::GetCharPointer(nameAddr); - u32 entry = PARAM(1); - u32 prio = PARAM(2); - int stacksize = PARAM(3); - u32 attr = PARAM(4); - //ignore PARAM(5) - SceUID id; __KernelCreateThread(id, curModule, threadName, entry, prio, stacksize, attr); - INFO_LOG(HLE,"%i = sceKernelCreateThread(name=\"%s\", entry= %08x, stacksize=%i )", id, threadName, entry, stacksize); - RETURN(id); + INFO_LOG(HLE, "%i = sceKernelCreateThread(name=\"%s\", entry=%08x, prio=%x, stacksize=%i)", id, threadName, entry, prio, stacksize); + if (optionAddr != 0) + WARN_LOG(HLE, "sceKernelCreateThread: unsupported options parameter.", threadName); + return id; } // int sceKernelStartThread(SceUID threadToStartID, SceSize argSize, void *argBlock) -// void because it reschedules. -void sceKernelStartThread(SceUID threadToStartID, u32 argSize, u32 argBlockPtr) +int sceKernelStartThread(SceUID threadToStartID, u32 argSize, u32 argBlockPtr) { if (threadToStartID != currentThread->GetUID()) { @@ -958,15 +951,13 @@ void sceKernelStartThread(SceUID threadToStartID, u32 argSize, u32 argBlockPtr) { ERROR_LOG(HLE,"%08x=sceKernelStartThread(thread=%i, argSize=%i, argPtr= %08x): thread does not exist!", error,threadToStartID,argSize,argBlockPtr) - RETURN(error); - return; + return error; } if (startThread->nt.status != THREADSTATUS_DORMANT) { //Not dormant, WTF? - RETURN(ERROR_KERNEL_THREAD_IS_NOT_DORMANT); - return; + return ERROR_KERNEL_THREAD_IS_NOT_DORMANT; } INFO_LOG(HLE,"sceKernelStartThread(thread=%i, argSize=%i, argPtr= %08x )", @@ -995,14 +986,14 @@ void sceKernelStartThread(SceUID threadToStartID, u32 argSize, u32 argBlockPtr) if (!argBlockPtr && argSize > 0) { WARN_LOG(HLE,"sceKernelStartThread : had NULL arg"); } - RETURN(0); hleReSchedule("thread started"); + return 0; } else { ERROR_LOG(HLE,"thread %i trying to start itself", threadToStartID); - RETURN(-1); + return -1; } } @@ -1142,63 +1133,60 @@ void sceKernelRotateThreadReadyQueue() hleReSchedule("rotatethreadreadyqueue"); } -void sceKernelDeleteThread() +int sceKernelDeleteThread(int threadHandle) { - int threadHandle = PARAM(0); if (threadHandle != currentThread->GetUID()) { //TODO: remove from threadqueue! DEBUG_LOG(HLE,"sceKernelDeleteThread(%i)",threadHandle); - u32 error; - Thread *t = kernelObjects.Get(threadHandle, error); - if (t) - { - __KernelRemoveFromThreadQueue(t); - __KernelFireThreadEnd(t); + u32 error; + Thread *t = kernelObjects.Get(threadHandle, error); + if (t) + { + __KernelRemoveFromThreadQueue(t); + __KernelFireThreadEnd(t); - RETURN(kernelObjects.Destroy(threadHandle)); + __KernelTriggerWait(WAITTYPE_THREADEND, threadHandle); - __KernelTriggerWait(WAITTYPE_THREADEND, threadHandle); - - //TODO: should we really reschedule here? - //if (!__KernelTriggerWait(WAITTYPE_THREADEND, threadHandle)) - // hleReSchedule("thread deleted"); - } + //TODO: should we really reschedule here? + //if (!__KernelTriggerWait(WAITTYPE_THREADEND, threadHandle)) + // hleReSchedule("thread deleted"); + return kernelObjects.Destroy(threadHandle); + } } else { ERROR_LOG(HLE, "Thread \"%s\" tries to delete itself! :(",currentThread->GetName()); - RETURN(-1); + return -1; } } -void sceKernelTerminateDeleteThread() +int sceKernelTerminateDeleteThread(int threadno) { - int threadno = PARAM(0); if (threadno != currentThread->GetUID()) { //TODO: remove from threadqueue! INFO_LOG(HLE, "sceKernelTerminateDeleteThread(%i)", threadno); - RETURN(0); //kernelObjects.Destroy(threadno)); //TODO: should we really reschedule here? if (!__KernelTriggerWait(WAITTYPE_THREADEND, threadno)) hleReSchedule("termdeletethread"); + + return 0; //kernelObjects.Destroy(threadno)); } else { ERROR_LOG(HLE, "Thread \"%s\" trying to delete itself! :(", currentThread->GetName()); - RETURN(-1); + return -1; } } -void sceKernelTerminateThread(u32 threadID) +int sceKernelTerminateThread(u32 threadID) { if (threadID != currentThread->GetUID()) { INFO_LOG(HLE, "sceKernelTerminateThread(%i)", threadID); - RETURN(0); u32 error; Thread *t = kernelObjects.Get(threadID, error); @@ -1209,11 +1197,12 @@ void sceKernelTerminateThread(u32 threadID) __KernelTriggerWait(WAITTYPE_THREADEND, threadID); } // TODO: Return an error if it doesn't exist? + return 0; } else { ERROR_LOG(HLE, "Thread \"%s\" trying to delete itself! :(", currentThread->GetName()); - RETURN(-1); + return -1; } } diff --git a/Core/HLE/sceKernelThread.h b/Core/HLE/sceKernelThread.h index 1770c62130..30998ea4ad 100644 --- a/Core/HLE/sceKernelThread.h +++ b/Core/HLE/sceKernelThread.h @@ -26,16 +26,16 @@ void sceKernelChangeThreadPriority(); -void sceKernelCreateThread(); +int sceKernelCreateThread(const char *threadName, u32 entry, u32 prio, int stacksize, u32 attr, u32 optionAddr); void sceKernelDelayThread(); void sceKernelDelayThreadCB(); -void sceKernelDeleteThread(); +int sceKernelDeleteThread(int threadHandle); void sceKernelExitDeleteThread(); void sceKernelExitThread(); void _sceKernelExitThread(); void sceKernelGetThreadId(); void sceKernelGetThreadCurrentPriority(); -void sceKernelStartThread(SceUID threadToStartID, u32 argSize, u32 argBlockPtr); +int sceKernelStartThread(SceUID threadToStartID, u32 argSize, u32 argBlockPtr); u32 sceKernelSuspendDispatchThread(); u32 sceKernelResumeDispatchThread(u32 suspended); void sceKernelWaitThreadEnd(); @@ -47,8 +47,8 @@ void sceKernelSuspendThread(); void sceKernelResumeThread(); void sceKernelWakeupThread(); void sceKernelCancelWakeupThread(); -void sceKernelTerminateDeleteThread(); -void sceKernelTerminateThread(u32 threadID); +int sceKernelTerminateDeleteThread(int threadno); +int sceKernelTerminateThread(u32 threadID); void sceKernelWaitThreadEndCB(); void sceKernelGetThreadExitStatus(); void sceKernelGetThreadmanIdType();