archive/Cemu
1
0
Fork 0
mirror of https://github.com/cemu-project/Cemu.git synced 2025-07-15 19:28:29 +12:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

Code cleanup

Browse source
This commit is contained in:
Exzap 2023-10-01 11:43:24 +02:00
parent 9523993a24
commit ff9d180154
26 changed files with 105 additions and 131 deletions
Download patch file Download diff file Expand all files Collapse all files

6
src/Cafe/OS/libs/coreinit/coreinit.cpp
View file

@ -35,7 +35,7 @@
#include "Cafe/OS/libs/coreinit/coreinit_MEM_BlockHeap.h"
#include "Cafe/OS/libs/coreinit/coreinit_MEM_ExpHeap.h"
coreinitData_t* gCoreinitData = NULL;
CoreinitSharedData* gCoreinitData = NULL;
sint32 ScoreStackTrace(OSThread_t* thread, MPTR sp)
{
@ -323,8 +323,8 @@ void coreinit_load()
coreinit::InitializeSysHeap();
// allocate coreinit global data
gCoreinitData = (coreinitData_t*)memory_getPointerFromVirtualOffset(coreinit_allocFromSysArea(sizeof(coreinitData_t), 32));
memset(gCoreinitData, 0x00, sizeof(coreinitData_t));
gCoreinitData = (CoreinitSharedData*)memory_getPointerFromVirtualOffset(coreinit_allocFromSysArea(sizeof(CoreinitSharedData), 32));
memset(gCoreinitData, 0x00, sizeof(CoreinitSharedData));
// coreinit weak links
osLib_addVirtualPointer("coreinit", "MEMAllocFromDefaultHeap", memory_getVirtualOffsetFromPointer(&gCoreinitData->MEMAllocFromDefaultHeap));

9
src/Cafe/OS/libs/coreinit/coreinit.h
View file

@ -16,8 +16,7 @@ void coreinitAsyncCallback_addWithLock(MPTR functionMPTR, uint32 numParameters,
void coreinit_load();
// coreinit shared memory
typedef struct
struct CoreinitSharedData
{
MEMPTR<void> MEMAllocFromDefaultHeap;
MEMPTR<void> MEMAllocFromDefaultHeapEx;
@ -26,11 +25,9 @@ typedef struct
MPTR __cpp_exception_init_ptr;
MPTR __cpp_exception_cleanup_ptr;
MPTR __stdio_cleanup;
}coreinitData_t;
};
extern coreinitData_t* gCoreinitData;
#include "Cafe/OS/libs/coreinit/coreinit_Spinlock.h"
extern CoreinitSharedData* gCoreinitData;
// coreinit init
void coreinit_start(PPCInterpreter_t* hCPU);

1
src/Cafe/OS/libs/coreinit/coreinit_MCP.cpp
View file

@ -71,7 +71,6 @@ sint32 MCP_GetSysProdSettings(MCPHANDLE mcpHandle, SysProdSettings* sysProdSetti
void coreinitExport_MCP_GetSysProdSettings(PPCInterpreter_t* hCPU)
{
cemuLog_logDebug(LogType::Force, "MCP_GetSysProdSettings(0x{:08x},0x{:08x})", hCPU->gpr[3], hCPU->gpr[4]);
sint32 result = MCP_GetSysProdSettings(hCPU->gpr[3], (SysProdSettings*)memory_getPointerFromVirtualOffset(hCPU->gpr[4]));
osLib_returnFromFunction(hCPU, result);
}

48
src/Cafe/OS/libs/coreinit/coreinit_Thread.cpp
View file

@ -198,7 +198,7 @@ namespace coreinit
void threadEntry(PPCInterpreter_t* hCPU)
{
OSThread_t* currentThread = coreinitThread_getCurrentThreadDepr(hCPU);
OSThread_t* currentThread = coreinit::OSGetCurrentThread();
uint32 r3 = hCPU->gpr[3];
uint32 r4 = hCPU->gpr[4];
uint32 lr = hCPU->spr.LR;
@ -368,39 +368,38 @@ namespace coreinit
{
PPCInterpreter_t* hCPU = PPCInterpreter_getCurrentInstance();
hCPU->gpr[3] = exitValue;
OSThread_t* threadBE = coreinitThread_getCurrentThreadDepr(hCPU);
MPTR t = memory_getVirtualOffsetFromPointer(threadBE);
OSThread_t* currentThread = coreinit::OSGetCurrentThread();
// thread cleanup callback
if (!threadBE->cleanupCallback2.IsNull())
if (!currentThread->cleanupCallback2.IsNull())
{
threadBE->stateFlags = _swapEndianU32(_swapEndianU32(threadBE->stateFlags) | 0x00000001);
PPCCoreCallback(threadBE->cleanupCallback2.GetMPTR(), threadBE, _swapEndianU32(threadBE->stackEnd));
currentThread->stateFlags = _swapEndianU32(_swapEndianU32(currentThread->stateFlags) | 0x00000001);
PPCCoreCallback(currentThread->cleanupCallback2.GetMPTR(), currentThread, _swapEndianU32(currentThread->stackEnd));
}
// cpp exception cleanup
if (gCoreinitData->__cpp_exception_cleanup_ptr != 0 && threadBE->crt.eh_globals != nullptr)
if (gCoreinitData->__cpp_exception_cleanup_ptr != 0 && currentThread->crt.eh_globals != nullptr)
{
PPCCoreCallback(_swapEndianU32(gCoreinitData->__cpp_exception_cleanup_ptr), &threadBE->crt.eh_globals);
threadBE->crt.eh_globals = nullptr;
PPCCoreCallback(_swapEndianU32(gCoreinitData->__cpp_exception_cleanup_ptr), &currentThread->crt.eh_globals);
currentThread->crt.eh_globals = nullptr;
}
// set exit code
threadBE->exitValue = exitValue;
currentThread->exitValue = exitValue;
__OSLockScheduler();
// release held synchronization primitives
if (!threadBE->mutexQueue.isEmpty())
if (!currentThread->mutexQueue.isEmpty())
{
cemuLog_log(LogType::Force, "OSExitThread: Thread is holding mutexes");
while (true)
{
OSMutex* mutex = threadBE->mutexQueue.getFirst();
OSMutex* mutex = currentThread->mutexQueue.getFirst();
if (!mutex)
break;
if (mutex->owner != threadBE)
if (mutex->owner != currentThread)
{
cemuLog_log(LogType::Force, "OSExitThread: Thread is holding mutex which it doesn't own");
threadBE->mutexQueue.removeMutex(mutex);
currentThread->mutexQueue.removeMutex(mutex);
continue;
}
coreinit::OSUnlockMutexInternal(mutex);
@ -409,22 +408,22 @@ namespace coreinit
// todo - release all fast mutexes
// handle join queue
if (!threadBE->joinQueue.isEmpty())
threadBE->joinQueue.wakeupEntireWaitQueue(false);
if (!currentThread->joinQueue.isEmpty())
currentThread->joinQueue.wakeupEntireWaitQueue(false);
if ((threadBE->attr & 8) != 0)
if ((currentThread->attr & 8) != 0)
{
// deactivate thread since it is detached
threadBE->state = OSThread_t::THREAD_STATE::STATE_NONE;
coreinit::__OSDeactivateThread(threadBE);
currentThread->state = OSThread_t::THREAD_STATE::STATE_NONE;
coreinit::__OSDeactivateThread(currentThread);
// queue call to thread deallocator if set
if (!threadBE->deallocatorFunc.IsNull())
__OSQueueThreadDeallocation(threadBE);
if (!currentThread->deallocatorFunc.IsNull())
__OSQueueThreadDeallocation(currentThread);
}
else
{
// non-detached threads remain active
threadBE->state = OSThread_t::THREAD_STATE::STATE_MORIBUND;
currentThread->state = OSThread_t::THREAD_STATE::STATE_MORIBUND;
}
PPCCore_switchToSchedulerWithLock();
}
@ -1401,11 +1400,6 @@ void coreinit_resumeThread(OSThread_t* OSThreadBE, sint32 count)
__OSUnlockScheduler();
}
MPTR coreinitThread_getCurrentThreadMPTRDepr(PPCInterpreter_t* hCPU)
{
return memory_getVirtualOffsetFromPointer(coreinit::__currentCoreThread[PPCInterpreter_getCoreIndex(hCPU)]);
}
OSThread_t* coreinitThread_getCurrentThreadDepr(PPCInterpreter_t* hCPU)
{
return coreinit::__currentCoreThread[PPCInterpreter_getCoreIndex(hCPU)];

5
src/Cafe/OS/libs/coreinit/coreinit_Thread.h
View file

@ -486,8 +486,8 @@ struct OSThread_t
/* +0x668 */ MPTR tlsBlocksMPTR;
/* +0x66C */ MEMPTR<coreinit::OSFastMutex> waitingForFastMutex;
/* +0x670 */ coreinit::OSFastMutexLink contendedFastMutex; // link or queue?
/* +0x678 */ coreinit::OSFastMutexLink ownedFastMutex; // link or queue?
/* +0x670 */ coreinit::OSFastMutexLink contendedFastMutex;
/* +0x678 */ coreinit::OSFastMutexLink ownedFastMutex;
/* +0x680 */ uint32 padding680[28 / 4];
};
@ -615,7 +615,6 @@ namespace coreinit
void coreinit_suspendThread(OSThread_t* OSThreadBE, sint32 count = 1);
void coreinit_resumeThread(OSThread_t* OSThreadBE, sint32 count = 1);
MPTR coreinitThread_getCurrentThreadMPTRDepr(PPCInterpreter_t* hCPU);
OSThread_t* coreinitThread_getCurrentThreadDepr(PPCInterpreter_t* hCPU);
extern MPTR activeThread[256];

5
src/Cafe/OS/libs/gx2/GX2.h
View file

@ -7,11 +7,6 @@
#define GX2_ENABLE 1
#define GX2_DISABLE 0
// tex unit base for render backends
#define CEMU_PS_TEX_UNIT_BASE 0
#define CEMU_VS_TEX_UNIT_BASE 32
#define CEMU_GS_TEX_UNIT_BASE 64
#include "GX2_Surface.h"
// general

4
src/Cafe/OS/libs/nlibcurl/nlibcurl.cpp
View file

@ -225,7 +225,7 @@ void CurlWorkerThread(CURL_t* curl, PPCConcurrentQueue<QueueMsg_t>* callerQueue,
uint32 SendOrderToWorker(CURL_t* curl, QueueOrder order, uint32 arg1 = 0)
{
OSThread_t* currentThread = coreinitThread_getCurrentThreadDepr(PPCInterpreter_getCurrentInstance());
OSThread_t* currentThread = coreinit::OSGetCurrentThread();
curl->curlThread = currentThread;
// cemuLog_logDebug(LogType::Force, "CURRENTTHREAD: 0x{} -> {}",currentThread, order)
@ -707,7 +707,7 @@ void export_curl_easy_init(PPCInterpreter_t* hCPU)
memset(result.GetPtr(), 0, sizeof(CURL_t));
*result = {};
result->curl = curl_easy_init();
result->curlThread = coreinitThread_getCurrentThreadDepr(PPCInterpreter_getCurrentInstance());
result->curlThread = coreinit::OSGetCurrentThread();
result->info_contentType = nullptr;
result->info_redirectUrl = nullptr;

1
src/Cafe/OS/libs/nn_act/nn_act.cpp
View file

@ -283,7 +283,6 @@ void nnActExport_GetSimpleAddressIdEx(PPCInterpreter_t* hCPU)
void nnActExport_GetPrincipalId(PPCInterpreter_t* hCPU)
{
// return error for non-nnid accounts?
cemuLog_logDebug(LogType::Force, "nn_act.GetPrincipalId()");
uint32be principalId;
GetPrincipalIdEx(&principalId, iosu::act::ACT_SLOT_CURRENT);
osLib_returnFromFunction(hCPU, (uint32)principalId);

55
src/Cafe/OS/libs/nn_save/nn_save.cpp
View file

@ -446,19 +446,20 @@ namespace save
SAVEStatus SAVEOpenFileOtherApplication(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint64 titleId, uint8 accountSlot, const char* path, const char* mode, FSFileHandleDepr_t* hFile, FS_ERROR_MASK errHandling)
{
MEMPTR<OSThread_t> currentThread{coreinit::OSGetCurrentThread()};
FSAsyncParamsNew_t asyncParams;
asyncParams.ioMsgQueue = nullptr;
asyncParams.userCallback = PPCInterpreter_makeCallableExportDepr(AsyncCallback);
StackAllocator<AsyncCallbackParam_t> param;
param->thread = coreinitThread_getCurrentThreadMPTRDepr(PPCInterpreter_getCurrentInstance());
param->thread = currentThread;
param->returnStatus = (FSStatus)FS_RESULT::SUCCESS;
asyncParams.userContext = param.GetPointer();
SAVEStatus status = SAVEOpenFileOtherApplicationAsync(client, block, titleId, accountSlot, path, mode, hFile, errHandling, &asyncParams);
if (status == (FSStatus)FS_RESULT::SUCCESS)
{
coreinit_suspendThread(coreinitThread_getCurrentThreadDepr(PPCInterpreter_getCurrentInstance()), 1000);
coreinit_suspendThread(currentThread, 1000);
PPCCore_switchToScheduler();
return param->returnStatus;
}
@ -680,19 +681,20 @@ namespace save
SAVEStatus SAVEGetFreeSpaceSize(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint8 accountSlot, FSLargeSize* freeSize, FS_ERROR_MASK errHandling)
{
MEMPTR<OSThread_t> currentThread{coreinit::OSGetCurrentThread()};
FSAsyncParams_t asyncParams;
asyncParams.ioMsgQueue = MPTR_NULL;
asyncParams.userCallback = _swapEndianU32(PPCInterpreter_makeCallableExportDepr(AsyncCallback));
StackAllocator<AsyncCallbackParam_t> param;
param->thread = coreinitThread_getCurrentThreadMPTRDepr(PPCInterpreter_getCurrentInstance());
param->thread = currentThread;
param->returnStatus = (FSStatus)FS_RESULT::SUCCESS;
asyncParams.userContext = param.GetMPTRBE();
SAVEStatus status = SAVEGetFreeSpaceSizeAsync(client, block, accountSlot, freeSize, errHandling, &asyncParams);
if (status == (FSStatus)FS_RESULT::SUCCESS)
{
coreinit_suspendThread(coreinitThread_getCurrentThreadDepr(PPCInterpreter_getCurrentInstance()), 1000);
coreinit_suspendThread(currentThread, 1000);
PPCCore_switchToScheduler();
return param->returnStatus;
}
@ -749,19 +751,20 @@ namespace save
SAVEStatus SAVERemove(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint8 accountSlot, const char* path, FS_ERROR_MASK errHandling)
{
MEMPTR<OSThread_t> currentThread{coreinit::OSGetCurrentThread()};
FSAsyncParams_t asyncParams;
asyncParams.ioMsgQueue = MPTR_NULL;
asyncParams.userCallback = _swapEndianU32(PPCInterpreter_makeCallableExportDepr(AsyncCallback));
StackAllocator<AsyncCallbackParam_t> param;
param->thread = coreinitThread_getCurrentThreadMPTRDepr(PPCInterpreter_getCurrentInstance());
param->thread = currentThread;
param->returnStatus = (FSStatus)FS_RESULT::SUCCESS;
asyncParams.userContext = param.GetMPTRBE();
SAVEStatus status = SAVERemoveAsync(client, block, accountSlot, path, errHandling, &asyncParams);
if (status == (FSStatus)FS_RESULT::SUCCESS)
{
coreinit_suspendThread(coreinitThread_getCurrentThreadDepr(PPCInterpreter_getCurrentInstance()), 1000);
coreinit_suspendThread(currentThread, 1000);
PPCCore_switchToScheduler();
return param->returnStatus;
}
@ -862,19 +865,20 @@ namespace save
SAVEStatus SAVEOpenDir(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint8 accountSlot, const char* path, FSDirHandlePtr hDir, FS_ERROR_MASK errHandling)
{
MEMPTR<OSThread_t> currentThread{coreinit::OSGetCurrentThread()};
FSAsyncParams_t asyncParams;
asyncParams.ioMsgQueue = MPTR_NULL;
asyncParams.userCallback = _swapEndianU32(PPCInterpreter_makeCallableExportDepr(AsyncCallback));
StackAllocator<AsyncCallbackParam_t> param;
param->thread = coreinitThread_getCurrentThreadMPTRDepr(PPCInterpreter_getCurrentInstance());
param->thread = currentThread;
param->returnStatus = (FSStatus)FS_RESULT::SUCCESS;
asyncParams.userContext = param.GetMPTRBE();
SAVEStatus status = SAVEOpenDirAsync(client, block, accountSlot, path, hDir, errHandling, &asyncParams);
if (status == (FSStatus)FS_RESULT::SUCCESS)
{
coreinit_suspendThread(coreinitThread_getCurrentThreadDepr(PPCInterpreter_getCurrentInstance()), 1000);
coreinit_suspendThread(currentThread, 1000);
PPCCore_switchToScheduler();
return param->returnStatus;
}
@ -935,19 +939,20 @@ namespace save
SAVEStatus SAVEOpenDirOtherApplication(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint64 titleId, uint8 accountSlot, const char* path, FSDirHandlePtr hDir, FS_ERROR_MASK errHandling)
{
MEMPTR<OSThread_t> currentThread{coreinit::OSGetCurrentThread()};
FSAsyncParams_t asyncParams;
asyncParams.ioMsgQueue = MPTR_NULL;
asyncParams.userCallback = _swapEndianU32(PPCInterpreter_makeCallableExportDepr(AsyncCallback));
StackAllocator<AsyncCallbackParam_t> param;
param->thread = coreinitThread_getCurrentThreadMPTRDepr(PPCInterpreter_getCurrentInstance());
param->thread = currentThread;
param->returnStatus = (FSStatus)FS_RESULT::SUCCESS;
asyncParams.userContext = param.GetMPTRBE();
SAVEStatus status = SAVEOpenDirOtherApplicationAsync(client, block, titleId, accountSlot, path, hDir, errHandling, &asyncParams);
if (status == (FSStatus)FS_RESULT::SUCCESS)
{
coreinit_suspendThread(coreinitThread_getCurrentThreadDepr(PPCInterpreter_getCurrentInstance()), 1000);
coreinit_suspendThread(currentThread, 1000);
PPCCore_switchToScheduler();
return param->returnStatus;
}
@ -1071,19 +1076,20 @@ namespace save
SAVEStatus SAVEMakeDir(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint8 accountSlot, const char* path, FS_ERROR_MASK errHandling)
{
MEMPTR<OSThread_t> currentThread{coreinit::OSGetCurrentThread()};
FSAsyncParams_t asyncParams;
asyncParams.ioMsgQueue = MPTR_NULL;
asyncParams.userCallback = _swapEndianU32(PPCInterpreter_makeCallableExportDepr(AsyncCallback));
StackAllocator<AsyncCallbackParam_t> param;
param->thread = coreinitThread_getCurrentThreadMPTRDepr(PPCInterpreter_getCurrentInstance());
param->thread = currentThread;
param->returnStatus = (FSStatus)FS_RESULT::SUCCESS;
asyncParams.userContext = param.GetMPTRBE();
SAVEStatus status = SAVEMakeDirAsync(client, block, accountSlot, path, errHandling, &asyncParams);
if (status == (FSStatus)FS_RESULT::SUCCESS)
{
coreinit_suspendThread(coreinitThread_getCurrentThreadDepr(PPCInterpreter_getCurrentInstance()), 1000);
coreinit_suspendThread(currentThread, 1000);
PPCCore_switchToScheduler();
return param->returnStatus;
}
@ -1122,19 +1128,20 @@ namespace save
SAVEStatus SAVEOpenFile(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint8 accountSlot, const char* path, const char* mode, FSFileHandleDepr_t* hFile, FS_ERROR_MASK errHandling)
{
MEMPTR<OSThread_t> currentThread{coreinit::OSGetCurrentThread()};
FSAsyncParamsNew_t asyncParams;
asyncParams.ioMsgQueue = nullptr;
asyncParams.userCallback = PPCInterpreter_makeCallableExportDepr(AsyncCallback);
StackAllocator<AsyncCallbackParam_t> param;
param->thread = coreinitThread_getCurrentThreadMPTRDepr(PPCInterpreter_getCurrentInstance());
param->thread = currentThread;
param->returnStatus = (FSStatus)FS_RESULT::SUCCESS;
asyncParams.userContext = param.GetPointer();
SAVEStatus status = SAVEOpenFileAsync(client, block, accountSlot, path, mode, hFile, errHandling, &asyncParams);
if (status == (FSStatus)FS_RESULT::SUCCESS)
{
coreinit_suspendThread(coreinitThread_getCurrentThreadDepr(PPCInterpreter_getCurrentInstance()), 1000);
coreinit_suspendThread(currentThread, 1000);
PPCCore_switchToScheduler();
return param->returnStatus;
}
@ -1182,19 +1189,20 @@ namespace save
SAVEStatus SAVEGetStat(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint8 accountSlot, const char* path, FSStat_t* stat, FS_ERROR_MASK errHandling)
{
MEMPTR<OSThread_t> currentThread{coreinit::OSGetCurrentThread()};
FSAsyncParams_t asyncParams;
asyncParams.ioMsgQueue = MPTR_NULL;
asyncParams.userCallback = _swapEndianU32(PPCInterpreter_makeCallableExportDepr(AsyncCallback));
StackAllocator<AsyncCallbackParam_t> param;
param->thread = coreinitThread_getCurrentThreadMPTRDepr(PPCInterpreter_getCurrentInstance());
param->thread = currentThread;
param->returnStatus = (FSStatus)FS_RESULT::SUCCESS;
asyncParams.userContext = param.GetMPTRBE();
SAVEStatus status = SAVEGetStatAsync(client, block, accountSlot, path, stat, errHandling, &asyncParams);
if (status == (FSStatus)FS_RESULT::SUCCESS)
{
coreinit_suspendThread(coreinitThread_getCurrentThreadDepr(PPCInterpreter_getCurrentInstance()), 1000);
coreinit_suspendThread(currentThread, 1000);
PPCCore_switchToScheduler();
return param->returnStatus;
}
@ -1233,19 +1241,20 @@ namespace save
SAVEStatus SAVEGetStatOtherApplication(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint64 titleId, uint8 accountSlot, const char* path, FSStat_t* stat, FS_ERROR_MASK errHandling)
{
MEMPTR<OSThread_t> currentThread{coreinit::OSGetCurrentThread()};
FSAsyncParams_t asyncParams;
asyncParams.ioMsgQueue = MPTR_NULL;
asyncParams.userCallback = _swapEndianU32(PPCInterpreter_makeCallableExportDepr(AsyncCallback));
StackAllocator<AsyncCallbackParam_t> param;
param->thread = coreinitThread_getCurrentThreadMPTRDepr(PPCInterpreter_getCurrentInstance());
param->thread = currentThread;
param->returnStatus = (FSStatus)FS_RESULT::SUCCESS;
asyncParams.userContext = param.GetMPTRBE();
SAVEStatus status = SAVEGetStatOtherApplicationAsync(client, block, titleId, accountSlot, path, stat, errHandling, &asyncParams);
if (status == (FSStatus)FS_RESULT::SUCCESS)
{
coreinit_suspendThread(coreinitThread_getCurrentThreadDepr(PPCInterpreter_getCurrentInstance()), 1000);
coreinit_suspendThread(currentThread, 1000);
PPCCore_switchToScheduler();
return param->returnStatus;
}
@ -1422,19 +1431,20 @@ namespace save
SAVEStatus SAVEChangeDir(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint8 accountSlot, const char* path, FS_ERROR_MASK errHandling)
{
MEMPTR<OSThread_t> currentThread{coreinit::OSGetCurrentThread()};
FSAsyncParams_t asyncParams;
asyncParams.ioMsgQueue = MPTR_NULL;
asyncParams.userCallback = _swapEndianU32(PPCInterpreter_makeCallableExportDepr(AsyncCallback));
StackAllocator<AsyncCallbackParam_t> param;
param->thread = coreinitThread_getCurrentThreadMPTRDepr(PPCInterpreter_getCurrentInstance());
param->thread = currentThread;
param->returnStatus = (FSStatus)FS_RESULT::SUCCESS;
asyncParams.userContext = param.GetMPTRBE();
SAVEStatus status = SAVEChangeDirAsync(client, block, accountSlot, path, errHandling, &asyncParams);
if (status == (FSStatus)FS_RESULT::SUCCESS)
{
coreinit_suspendThread(coreinitThread_getCurrentThreadDepr(PPCInterpreter_getCurrentInstance()), 1000);
coreinit_suspendThread(currentThread, 1000);
PPCCore_switchToScheduler();
return param->returnStatus;
}
@ -1491,19 +1501,20 @@ namespace save
SAVEStatus SAVEFlushQuota(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint8 accountSlot, FS_ERROR_MASK errHandling)
{
MEMPTR<OSThread_t> currentThread{coreinit::OSGetCurrentThread()};
FSAsyncParams_t asyncParams;
asyncParams.ioMsgQueue = MPTR_NULL;
asyncParams.userCallback = _swapEndianU32(PPCInterpreter_makeCallableExportDepr(AsyncCallback));
StackAllocator<AsyncCallbackParam_t> param;
param->thread = coreinitThread_getCurrentThreadMPTRDepr(PPCInterpreter_getCurrentInstance());
param->thread = currentThread;
param->returnStatus = (FSStatus)FS_RESULT::SUCCESS;
asyncParams.userContext = param.GetMPTRBE();
SAVEStatus status = SAVEFlushQuotaAsync(client, block, accountSlot, errHandling, &asyncParams);
if (status == (FSStatus)FS_RESULT::SUCCESS)
{
coreinit_suspendThread(coreinitThread_getCurrentThreadDepr(PPCInterpreter_getCurrentInstance()), 1000);
coreinit_suspendThread(currentThread, 1000);
PPCCore_switchToScheduler();
return param->returnStatus;
}

2
src/Cafe/OS/libs/nsysnet/nsysnet.cpp
View file

@ -85,7 +85,7 @@ void nsysnetExport_socket_lib_finish(PPCInterpreter_t* hCPU)
uint32* __gh_errno_ptr()
{
OSThread_t* osThread = coreinitThread_getCurrentThreadDepr(PPCInterpreter_getCurrentInstance());
OSThread_t* osThread = coreinit::OSGetCurrentThread();
return &osThread->context.error;
}