archive/Cemu
1
0
Fork 0
mirror of https://github.com/cemu-project/Cemu.git synced 2025-07-07 23:41:18 +12:00
Code Issues Projects Releases Packages Wiki Activity Actions

Fix various issues

Browse source
This commit is contained in:
Chris Spegal 2023-10-10 21:55:54 -04:00
parent 1b7c4d8a2f
commit f44e12f4d8
16 changed files with 216 additions and 84 deletions
Download patch file Download diff file Expand all files Collapse all files

25
src/Cafe/CafeSystem.cpp
View file

@ -1003,10 +1003,7 @@ namespace CafeSystem
PauseTitle();
// memory
memory_Serialize(writer);
// gpu
writer.writeData(LatteGPUState.contextRegister, sizeof(LatteGPUState.contextRegister));
writer.writeData(LatteGPUState.contextRegisterShadowAddr, sizeof(LatteGPUState.contextRegister));
writer.writeData(LatteGPUState.sharedArea, sizeof(gx2GPUSharedArea_t));
nn::temp::save(writer);
nn::aoc::save(writer);
@ -1015,6 +1012,11 @@ namespace CafeSystem
iosu::fsa::save(writer);
iosu::odm::save(writer);
// gpu
writer.writeData(LatteGPUState.contextRegister, sizeof(LatteGPUState.contextRegister));
writer.writeData(LatteGPUState.contextRegisterShadowAddr, sizeof(LatteGPUState.contextRegister));
writer.writeData(LatteGPUState.sharedArea, sizeof(gx2GPUSharedArea_t));
FileStream* stream = FileStream::createFile(path);
stream->writeData(writer.getResult().data(), writer.getResult().size_bytes());
delete stream;
@ -1025,8 +1027,10 @@ namespace CafeSystem
void LoadState(std::string path)
{
PauseTitle();
//coreinit::__OSDeleteAllActivePPCThreads();
DestroyMemorySpace();
cemuLog_log(LogType::SaveStates, "Loading state...", path);
auto data = FileStream::LoadIntoMemory(path);
@ -1034,12 +1038,8 @@ namespace CafeSystem
MemStreamReader reader(data->data(), data->size());
// memory
DestroyMemorySpace();
memory_Deserialize(reader);
// gpu
reader.readData(LatteGPUState.contextRegister, sizeof(LatteGPUState.contextRegister));
reader.readData(LatteGPUState.contextRegisterShadowAddr, sizeof(LatteGPUState.contextRegister));
reader.readData(LatteGPUState.sharedArea, sizeof(gx2GPUSharedArea_t));
nn::temp::restore(reader);
nn::aoc::restore(reader);
@ -1048,6 +1048,11 @@ namespace CafeSystem
iosu::fsa::restore(reader);
iosu::odm::restore(reader);
// gpu
reader.readData(LatteGPUState.contextRegister, sizeof(LatteGPUState.contextRegister));
reader.readData(LatteGPUState.contextRegisterShadowAddr, sizeof(LatteGPUState.contextRegister));
reader.readData(LatteGPUState.sharedArea, sizeof(gx2GPUSharedArea_t));
cemuLog_log(LogType::SaveStates, "Loaded state from {}.", path);
ResumeTitle(/*isThreadRunning*/);

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

@ -319,8 +319,7 @@ namespace coreinit
void coreinit_save(MemStreamWriter& s)
{
s.writeSection("coreinit");
s.writeData(gCoreinitData, sizeof(coreinitData_t));
s.writeNullableData(gCoreinitData, sizeof(coreinitData_t));
s.write(placeholderFont);
s.write(placeholderFontSize);
@ -347,18 +346,13 @@ void coreinit_save(MemStreamWriter& s)
void coreinit_restore(MemStreamReader& s)
{
s.readSection("coreinit");
bool recreate = false;
if (recreate)
coreinit::__OSDeleteAllActivePPCThreads();
s.readData(gCoreinitData, sizeof(coreinitData_t));
s.readNullableData(gCoreinitData, sizeof(coreinitData_t));
s.read(placeholderFont);
s.read(placeholderFontSize);
coreinit_Init_Restore(s);
coreinit::SysHeap_Restore(s);
coreinit::Thread_Restore(s, recreate);
coreinit::Thread_Restore(s);
coreinit::MEM_Restore(s);
coreinit::FG_Restore(s);
coreinit::OverlayArena_Restore(s);

15
src/Cafe/OS/libs/coreinit/coreinit_CodeGen.cpp
View file

@ -25,9 +25,10 @@ namespace coreinit
}
}
static constexpr uint32 const codegenSize = 0x01000000; // todo: Read from cos.xml
void OSGetCodegenVirtAddrRange(betype<uint32>* rangeStart, betype<uint32>* rangeSize)
{
uint32 codegenSize = 0x01000000; // todo: Read from cos.xml
//debug_printf("OSGetCodegenVirtAddrRange(0x%08x,0x%08x)\n", hCPU->gpr[3], hCPU->gpr[4]);
// on first call, allocate range
if( coreinitCodeGen.rangeIsAllocated == false )
@ -139,13 +140,21 @@ namespace coreinit
void CodeGen_Save(MemStreamWriter& s)
{
s.writeSection("coreinit_CodeGen");
s.writeData(&coreinitCodeGen, sizeof(coreinitCodeGen));
s.writeBool(coreinitCodeGen.rangeIsAllocated);
s.write(coreinitCodeGen.rangeStart);
s.write(coreinitCodeGen.rangeSize);
s.write(codegenSize);
s.writeNullableData(coreinitCodeGen.cacheStateCopy, codegenSize);
}
void CodeGen_Restore(MemStreamReader& s)
{
s.readSection("coreinit_CodeGen");
s.readData(&coreinitCodeGen, sizeof(coreinitCodeGen));
s.readBool(coreinitCodeGen.rangeIsAllocated);
s.read(coreinitCodeGen.rangeStart);
s.read(coreinitCodeGen.rangeSize);
cemu_assert(s.read<uint32>() == codegenSize);
s.readNullableData(coreinitCodeGen.cacheStateCopy, codegenSize);
}
void InitializeCodeGen()

4
src/Cafe/OS/libs/coreinit/coreinit_FS.cpp
View file

@ -2641,7 +2641,7 @@ namespace coreinit
void FS_Save(MemStreamWriter& s)
{
s.writeSection("coreinit_FS");
s.writeData(g_fsRegisteredClientBodies, sizeof(FSClientBody_t));
s.writePTR(g_fsRegisteredClientBodies);
s.writeBool(_sdCard01Mounted);
s.writeBool(_mlc01Mounted);
s.writeMPTR(_tempFSSpace);
@ -2654,7 +2654,7 @@ namespace coreinit
void FS_Restore(MemStreamReader& s)
{
s.readSection("coreinit_FS");
s.readData(g_fsRegisteredClientBodies, sizeof(FSClientBody_t));
s.readPTR(g_fsRegisteredClientBodies);
s.readBool(_sdCard01Mounted);
s.readBool(_mlc01Mounted);
s.readMPTR(_tempFSSpace);

4
src/Cafe/OS/libs/coreinit/coreinit_Init.cpp
View file

@ -219,7 +219,7 @@ void coreinit_start(PPCInterpreter_t* hCPU)
void coreinit_Init_Save(MemStreamWriter& s)
{
s.writeSection("coreinit_Init");
s.writeData(_coreinitInfo, sizeof(coreinitInit_t));
s.writeNullableData(_coreinitInfo, sizeof(coreinitInit_t));
s.write(argStorageIndex);
s.writeMPTR(g_preinitUserParam);
s.write(_coreinitTitleEntryPoint);
@ -228,7 +228,7 @@ void coreinit_Init_Save(MemStreamWriter& s)
void coreinit_Init_Restore(MemStreamReader& s)
{
s.readSection("coreinit_Init");
s.readData(_coreinitInfo, sizeof(coreinitInit_t));
s.readNullableData(_coreinitInfo, sizeof(coreinitInit_t));
s.read(argStorageIndex);
s.readMPTR(g_preinitUserParam);
s.read(_coreinitTitleEntryPoint);

4
src/Cafe/OS/libs/coreinit/coreinit_SysHeap.cpp
View file

@ -35,7 +35,7 @@ namespace coreinit
void SysHeap_Save(MemStreamWriter& s)
{
s.writeSection("coreinit_SysHeap");
s.writeData(_sysHeapHandle, sizeof(MEMHeapBase));
s.writePTR(_sysHeapHandle);
s.write(_sysHeapAllocCounter);
s.write(_sysHeapFreeCounter);
}
@ -43,7 +43,7 @@ namespace coreinit
void SysHeap_Restore(MemStreamReader& s)
{
s.readSection("coreinit_SysHeap");
s.readData(_sysHeapHandle, sizeof(MEMHeapBase));
s.readPTR(_sysHeapHandle);
s.read(_sysHeapAllocCounter);
s.read(_sysHeapFreeCounter);
}

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

@ -13,6 +13,7 @@
#include "util/Fiber/Fiber.h"
#include "util/helpers/helpers.h"
#include "Common/FileStream.h"
SlimRWLock srwlock_activeThreadList;
@ -1331,11 +1332,27 @@ namespace coreinit
}
}
void DumpActiveThreads(std::string v)
{
for (auto& thr : activeThread)
{
if (thr != MPTR_NULL)
{
auto* ptr = (OSThread_t*)memory_getPointerFromVirtualOffset(thr);
MemStreamWriter writer(0);
writer.writeData(ptr, sizeof(OSThread_t));
FileStream* stream = FileStream::createFile(std::to_string(thr) + "_" + v + ".bin");
stream->writeData(writer.getResult().data(), writer.getResult().size_bytes());
delete stream;
}
}
}
void Thread_Save(MemStreamWriter& s)
{
s.writeSection("coreinit_Thread");
s.write((uint8)sSchedulerActive.load());
s.writeAtomic(sSchedulerActive);
s.writeMPTR(g_activeThreadQueue);
s.writeMPTR(g_coreRunQueue);
@ -1343,6 +1360,8 @@ namespace coreinit
for (sint32 i = 0; i < activeThreadCount; i++)
{
s.write(activeThread[i]);
auto* ptr = (OSThread_t*)memory_getPointerFromVirtualOffset(activeThread[i]);
//s.write((uint8)ptr->state.value());
}
for (sint32 i = 0; i < PPC_CORE_COUNT; i++)
{
@ -1356,25 +1375,32 @@ namespace coreinit
}
s.writeMPTR(s_defaultThreads);
s.writeMPTR(s_stack);
DumpActiveThreads("save");
}
void Thread_Restore(MemStreamReader& s, bool recreate)
void Thread_Restore(MemStreamReader& s)
{
s.readSection("coreinit_Thread");
sSchedulerActive.store(s.read<uint8>());
s.readAtomic(sSchedulerActive);
s.readMPTR(g_activeThreadQueue);
s.readMPTR(g_coreRunQueue);
bool recreate = false;
sint32 prevActiveThreadCount = s.read<sint32>();
for (sint32 i = 0; i < prevActiveThreadCount; i++)
{
MPTR threadMPTR = s.read<MPTR>();
if (recreate)
{
auto* ptr = (OSThread_t*)memory_getPointerFromVirtualOffset(threadMPTR);
__OSLockScheduler();
__OSActivateThread((OSThread_t*)memory_getPointerFromVirtualOffset(threadMPTR));
__OSActivateThread(ptr);
__OSUnlockScheduler();
//ptr->state = betype((OSThread_t::THREAD_STATE)s.read<uint8>());
}
else
{
@ -1394,6 +1420,8 @@ namespace coreinit
}
s.readMPTR(s_defaultThreads);
s.readMPTR(s_stack);
DumpActiveThreads("restore");
}
void SuspendActiveThreads()

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

@ -497,7 +497,7 @@ static_assert(sizeof(OSThread_t) == 0x6A0-4); // todo - determine correct size
namespace coreinit
{
void Thread_Save(MemStreamWriter& s);
void Thread_Restore(MemStreamReader& s, bool recreate);
void Thread_Restore(MemStreamReader& s);
void SuspendActiveThreads();
void ResumeActiveThreads();

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

@ -742,13 +742,15 @@ namespace nn
void save(MemStreamWriter& s)
{
s.writeSection("nn_fp");
s.writeData(&g_fp, sizeof(g_fp));
s.writeBool(g_fp.isAdminMode);
s.writeBool(g_fp.isInitialized);
}
void restore(MemStreamReader& s)
{
s.readSection("nn_fp");
s.readData(&g_fp, sizeof(g_fp));
s.readBool(g_fp.isAdminMode);
s.readBool(g_fp.isInitialized);
}
void load()

36
src/Cafe/OS/libs/nn_nfp/nn_nfp.cpp
View file

@ -1018,13 +1018,45 @@ namespace nn::nfp
void save(MemStreamWriter& s)
{
s.writeSection("nn_nfp");
s.writeData(&nfp_data, sizeof(nfp_data));
s.writeBool(nfp_data.nfpIsInitialized);
s.write(nfp_data.activateEvent);
s.write(nfp_data.deactivateEvent);
s.writeBool(nfp_data.isDetecting);
s.writeBool(nfp_data.isMounted);
s.writeBool(nfp_data.isReadOnly);
s.writeBool(nfp_data.hasOpenApplicationArea);
s.writeBool(nfp_data.hasActiveAmiibo);
s.writeBool(nfp_data.hasInvalidHMAC);
s.write(nfp_data.amiiboTouchTime);
s.write<uint32>(sizeof(AmiiboRawNFCData));
s.writeData(&nfp_data.amiiboNFCData, sizeof(AmiiboRawNFCData));
s.write<uint32>(sizeof(AmiiboInternal));
s.writeData(&nfp_data.amiiboInternal, sizeof(AmiiboInternal));
s.write<uint32>(sizeof(AmiiboProcessedData));
s.writeData(&nfp_data.amiiboProcessedData, sizeof(AmiiboProcessedData));
}
void restore(MemStreamReader& s)
{
s.readSection("nn_nfp");
s.readData(&nfp_data, sizeof(nfp_data));
s.readBool(nfp_data.nfpIsInitialized);
s.read(nfp_data.activateEvent);
s.read(nfp_data.deactivateEvent);
s.readBool(nfp_data.isDetecting);
s.readBool(nfp_data.isMounted);
s.readBool(nfp_data.isReadOnly);
s.readBool(nfp_data.hasOpenApplicationArea);
s.readBool(nfp_data.hasActiveAmiibo);
s.readBool(nfp_data.hasInvalidHMAC);
s.read(nfp_data.amiiboTouchTime);
cemu_assert(s.read<uint32>() == sizeof(AmiiboRawNFCData));
s.readData(&nfp_data.amiiboNFCData, sizeof(AmiiboRawNFCData));
cemu_assert(s.read<uint32>() == sizeof(AmiiboInternal));
s.readData(&nfp_data.amiiboInternal, sizeof(AmiiboInternal));
cemu_assert(s.read<uint32>() == sizeof(AmiiboProcessedData));
s.readData(&nfp_data.amiiboProcessedData, sizeof(AmiiboProcessedData));
}
void load()

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

@ -116,7 +116,9 @@ namespace nn
s.writeMPTR(s_OlvReleaseBgThread);
s.writeMPTR(s_OlvReleaseBgThreadStack);
s.writeMPTR(s_OlvReleaseBgThreadName);
s.write<uint32>(sizeof(ParamPackStorage));
s.writeData(&g_ParamPack, sizeof(ParamPackStorage));
s.write<uint32>(sizeof(DiscoveryResultStorage));
s.writeData(&g_DiscoveryResults, sizeof(DiscoveryResultStorage));
s.write(g_ReportTypes);
s.writeBool(g_IsInitialized);
@ -131,7 +133,9 @@ namespace nn
s.readMPTR(s_OlvReleaseBgThread);
s.readMPTR(s_OlvReleaseBgThreadStack);
s.readMPTR(s_OlvReleaseBgThreadName);
cemu_assert(s.read<uint32>() == sizeof(ParamPackStorage));
s.readData(&g_ParamPack, sizeof(ParamPackStorage));
cemu_assert(s.read<uint32>() == sizeof(DiscoveryResultStorage));
s.readData(&g_DiscoveryResults, sizeof(DiscoveryResultStorage));
s.read(g_ReportTypes);
s.readBool(g_IsInitialized);

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

@ -18,13 +18,13 @@ void nnUdsExport___sti___11_uds_Api_cpp_f5d9abb2(PPCInterpreter_t* hCPU)
void nnUds_save(MemStreamWriter& s)
{
s.writeSection("nn_uds");
s.writeData(udsWorkspace, sizeof(udsWorkspace_t));
s.writeNullableData(udsWorkspace, sizeof(udsWorkspace_t));
}
void nnUds_restore(MemStreamReader& s)
{
s.readSection("nn_uds");
s.readData(udsWorkspace, sizeof(udsWorkspace_t));
s.readNullableData(udsWorkspace, sizeof(udsWorkspace_t));
}
/*

8
src/Cafe/OS/libs/nsyshid/nsyshid.cpp
View file

@ -816,8 +816,8 @@ namespace nsyshid
void save(MemStreamWriter& s)
{
s.writeSection("nsyshid");
s.writeData(firstDevice, sizeof(HIDDeviceInfo_t));
s.writeData(firstHIDClient, sizeof(HIDClient_t));
s.writePTR(firstDevice);
s.writeNullableData(firstHIDClient, sizeof(HIDClient_t));
s.write(_lastGeneratedHidHandle);
s.writeMPTR(_devicePool);
s.write(_devicePoolMask.count());
@ -826,8 +826,8 @@ namespace nsyshid
void restore(MemStreamReader& s)
{
s.readSection("nsyshid");
s.readData(firstDevice, sizeof(HIDDeviceInfo_t));
s.readData(firstHIDClient, sizeof(HIDClient_t));
s.readPTR(firstDevice);
s.readNullableData(firstHIDClient, sizeof(HIDClient_t));
s.read(_lastGeneratedHidHandle);
s.readMPTR(_devicePool);
_devicePoolMask.reset();

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

@ -2212,6 +2212,7 @@ void nsysnet_save(MemStreamWriter& s)
for (auto i : nsysnet::g_nsslInternalStates)
s.write(i);
s.writeBool(sockLibReady);
s.write<uint32>(sizeof(virtualSocket_t) * WU_SOCKET_LIMIT);
s.writeData(virtualSocketTable, sizeof(virtualSocket_t) * WU_SOCKET_LIMIT);
}
@ -2233,6 +2234,7 @@ void nsysnet_restore(MemStreamReader& s)
nsysnet::g_nsslInternalStates.push_back(t);
}
s.readBool(sockLibReady);
cemu_assert(s.read<uint32>() == sizeof(virtualSocket_t) * WU_SOCKET_LIMIT);
s.readData(virtualSocketTable, sizeof(virtualSocket_t) * WU_SOCKET_LIMIT);
}

100
src/Cafe/OS/libs/padscore/padscore.cpp
View file

@ -53,7 +53,7 @@ namespace padscore
WPADState_t g_wpad_state = kWPADStateMaster;
struct g_padscore_t
typedef struct _g_padscore_t
{
SysAllocator<coreinit::OSAlarm_t> alarm;
bool kpad_initialized = false;
@ -72,7 +72,9 @@ namespace padscore
} controller_data[InputManager::kMaxWPADControllers] = {};
int max_controllers = kWPADMaxControllers; // max bt controllers?
} g_padscore;
} g_padscore_t;
g_padscore_t g_padscore;
}
@ -747,30 +749,6 @@ namespace padscore
OSSetPeriodicAlarm(&g_padscore.alarm, start_tick, period_tick, handler);
}
void save(MemStreamWriter& s)
{
s.writeSection("padscore");
s.writeBool(debugUseDRC1);
s.writeBool(g_kpadIsInited);
s.writeData(&g_padscore, sizeof(g_padscore_t));
s.writeData(g_kpad_ringbuffer, sizeof(KPADUnifiedWpadStatus_t));
s.write(g_kpad_ringbuffer_length);
s.writeBool(g_wpad_callback_by_kpad);
s.write((uint32)g_wpad_state);
}
void restore(MemStreamReader& s)
{
s.readSection("padscore");
s.readBool(debugUseDRC1);
s.readBool(g_kpadIsInited);
s.readData(&g_padscore, sizeof(g_padscore_t));
s.readData(g_kpad_ringbuffer, sizeof(KPADUnifiedWpadStatus_t));
s.read(g_kpad_ringbuffer_length);
s.readBool(g_wpad_callback_by_kpad);
g_wpad_state = (WPADState_t)s.read<uint32>();
}
void load()
{
cafeExportRegister("padscore", WPADIsMplsAttached, LogType::InputAPI);
@ -813,3 +791,73 @@ namespace padscore
}
}
template<>
void MemStreamWriter::write(const padscore::g_padscore_t& v)
{
writeMPTR(v.alarm);
writeBool(v.kpad_initialized);
write<uint32>(InputManager::kMaxWPADControllers);
for (auto i : v.controller_data)
{
writeMPTR(i.extension_callback);
writeMPTR(i.connectCallback);
writeMPTR(i.sampling_callback);
writeMPTR(i.dpd_callback);
writeBool(i.dpd_enabled);
writeBool(i.disconnectCalled);
writeBool(i.disconnectCalled);
write(i.btn_repeat.delay);
write(i.btn_repeat.pulse);
}
write(v.max_controllers);
}
template <>
void MemStreamReader::read(padscore::g_padscore_t& v)
{
readMPTR(v.alarm);
readBool(v.kpad_initialized);
cemu_assert(read<uint32>() == InputManager::kMaxWPADControllers);
for (auto i : v.controller_data)
{
readMPTR(i.extension_callback);
readMPTR(i.connectCallback);
readMPTR(i.sampling_callback);
readMPTR(i.dpd_callback);
readBool(i.dpd_enabled);
readBool(i.disconnectCalled);
readBool(i.disconnectCalled);
read(i.btn_repeat.delay);
read(i.btn_repeat.pulse);
}
read(v.max_controllers);
}
namespace padscore
{
void save(MemStreamWriter& s)
{
s.writeSection("padscore");
s.writeBool(debugUseDRC1);
s.writeBool(g_kpadIsInited);
s.write(g_padscore);
s.writePTR(g_kpad_ringbuffer);
s.write(g_kpad_ringbuffer_length);
s.writeBool(g_wpad_callback_by_kpad);
s.write((uint32)g_wpad_state);
}
void restore(MemStreamReader& s)
{
s.readSection("padscore");
s.readBool(debugUseDRC1);
s.readBool(g_kpadIsInited);
s.read(g_padscore);
s.readPTR(g_kpad_ringbuffer);
s.read(g_kpad_ringbuffer_length);
s.readBool(g_wpad_callback_by_kpad);
g_wpad_state = (WPADState_t)s.read<uint32>();
}
}

28
src/util/helpers/Serializer.h
View file

@ -125,13 +125,6 @@ public:
}
bool readData(void* ptr, size_t size)
{
if (readBE<uint8>())
{
ptr = NULL;
return false;
}
else
{
if (m_cursorPos + size > m_size)
{
@ -143,6 +136,18 @@ public:
m_cursorPos += (sint32)size;
return true;
}
bool readNullableData(void* ptr, size_t size)
{
if (readBE<uint8>())
{
ptr = NULL;
return false;
}
else
{
return readData(ptr, size);
}
}
std::span<uint8> readDataNoCopy(size_t size)
@ -209,14 +214,17 @@ public:
}
void writeData(const void* ptr, size_t size)
{
writeBE((uint8)(ptr == NULL));
if (ptr)
{
m_buffer.resize(m_buffer.size() + size);
uint8* p = m_buffer.data() + m_buffer.size() - size;
memcpy(p, ptr, size);
}
void writeNullableData(void* ptr, size_t size)
{
writeBE((uint8)(ptr == NULL));
if (ptr)
writeData(ptr, size);
}
template<typename T> void write(const T& v);