Map mem range as needed; save/restore for coreinit; add logging for save states

src/Cafe/CafeSystem.cpp

@@ -981,7 +981,8 @@ namespace CafeSystem
 	{
 		if (!sSystemRunning)
 			return;
-		coreinit::SuspendAllThreads();
+		coreinit::SuspendActiveThreads();
+		iosu::pdm::Stop();
 		sSystemRunning = false;
 	}
 
@@ -989,13 +990,14 @@ namespace CafeSystem
 	{
 		if (sSystemRunning)
 			return;
-		coreinit::ResumeAllThreads();
+		coreinit::ResumeActiveThreads();
+		iosu::pdm::StartTrackingTime(GetForegroundTitleId());
 		sSystemRunning = true;
 	}
 
 	void SaveState(std::string path)
 	{
-		cemuLog_log(LogType::Force, "[SAVESTATE] Saving state...");
+		cemuLog_log(LogType::SaveStates, "Saving state...");
 		MemStreamWriter writer(0);
 		// pause game
 		PauseTitle();
@@ -1006,45 +1008,53 @@ namespace CafeSystem
 		writer.writeData(LatteGPUState.contextRegisterShadowAddr, sizeof(LatteGPUState.contextRegister));
 		writer.writeData(LatteGPUState.sharedArea, sizeof(gx2GPUSharedArea_t));
 		// cpu
-		for (auto& thr : activeThread)
+		ci_Save(writer);
-		{
+		coreinit::ci_Alarm_Save(writer);
-			writer.writeBE(thr);
+		ci_Callbacks_Save(writer);
-		}
+		coreinit::ci_FS_Save(writer);
-		// fs
+		ci_Init_Save(writer);
-		coreinit::FSSave(writer);
+		coreinit::ci_Thread_Save(writer);
 		iosu::fsa::Save(writer);
 
 		FileStream* stream = FileStream::createFile(path);
 		stream->writeData(writer.getResult().data(), writer.getResult().size_bytes());
 		delete stream;
-		cemuLog_log(LogType::Force, "[SAVESTATE] Saved state to {}.", path);
+		cemuLog_log(LogType::SaveStates, "Saved state to {}.", path);
+
 		ResumeTitle(/*isThreadRunning*/);
 	}
 
 	void LoadState(std::string path)
 	{
+		
 		PauseTitle();
-		cemuLog_log(LogType::Force, "[SAVESTATE] Loading state...", path);
+		cemuLog_log(LogType::SaveStates, "Loading state...", path);
 
 		auto data = FileStream::LoadIntoMemory(path);
 		assert(data.has_value());
 		MemStreamReader reader(data->data(), data->size());
+
+		bool recreate = false;
+		if (recreate)
+			coreinit::__OSDeleteAllActivePPCThreads();
+
 		// 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));
 		// cpu
-		for (size_t i = 0; i < 256; i++)
+		ci_Restore(reader);
-		{
+		coreinit::ci_Alarm_Restore(reader);
-			activeThread[i] = reader.readBE<uint32>();
+		ci_Callbacks_Restore(reader);
-		}
+		coreinit::ci_FS_Restore(reader);
-		// fs
+		ci_Init_Restore(reader);
-		coreinit::FSRestore(reader);
+		coreinit::ci_Thread_Restore(reader, recreate);
 		iosu::fsa::Restore(reader);
 
-		cemuLog_log(LogType::Force, "[SAVESTATE] Loaded state from {}.", path);
+		cemuLog_log(LogType::SaveStates, "Loaded state from {}.", path);
 
 		ResumeTitle(/*isThreadRunning*/);
 	}

src/Cafe/HW/MMU/MMU.cpp

@@ -110,13 +110,16 @@ void MemStreamWriter::writeBE<MMURange>(const MMURange& v)
 template <>
 void MemStreamReader::readBE<MMURange>(MMURange& mmuRange)
 {
-	mmuRange.m_isMapped = readBE<bool>();
+	bool needsMapped = readBE<bool>();
+	mmuRange.m_isMapped = false;
 	mmuRange.baseAddress = readBE<uint32>();
 	mmuRange.areaId = (MMU_MEM_AREA_ID)readBE<uint8>();
 	mmuRange.flags = (MMURange::MFLAG)readBE<uint8>();
 	mmuRange.name = readBE<std::string>();
 	mmuRange.size = readBE<uint32>();
 	mmuRange.initSize = readBE<uint32>();
+	if (needsMapped)
+		mmuRange.mapMem();
 }
 
 bool MMURange::deserializeImpl(MemStreamReader& streamReader)
@@ -470,7 +473,6 @@ void memory_createDump()
 
 void memory_Serialize(MemStreamWriter& s)
 {
-	s.writeBE<uint64>(g_mmuRanges.size());
 	for (auto& itr : g_mmuRanges)
 	{
 		s.writeBE(*itr);
@@ -483,7 +485,6 @@ void memory_Serialize(MemStreamWriter& s)
 
 void memory_Deserialize(MemStreamReader& s)
 {
-	size_t cnt = s.readBE<uint64>();
 	for (auto& itr : g_mmuRanges)
 	{
 		s.readBE<MMURange>(*itr);

src/Cafe/IOSU/fsa/iosu_fsa.cpp

@@ -992,6 +992,8 @@ namespace iosu::fsa
 
 	void Save(MemStreamWriter& writer)
 	{
+		writer.writeData("iosu_fsa_S", 15);
+
 		writer.writeBE(sFSAIoMsgQueue);
 		for (size_t i = 0; i < 352; i++)
 		{
@@ -1003,6 +1005,10 @@ namespace iosu::fsa
 
 	void Restore(MemStreamReader& reader)
 	{
+		char section[16] = { '\0' };
+		reader.readData(section, 15);
+		cemu_assert_debug(strcmp(section, "iosu_fsa_S") == 0);
+
 		sFSAIoMsgQueue = reader.readBE<IOSMsgQueueId>();
 		for (size_t i = 0; i < 352; i++)
 		{

src/Cafe/OS/libs/coreinit/coreinit.cpp

@@ -316,6 +316,56 @@ namespace coreinit
 	}
 };
 
+void ci_Save(MemStreamWriter& s)
+{
+	s.writeData("ci_S", 15);
+
+	s.writeData(gCoreinitData, sizeof(coreinitData_t));
+	s.writeBE(placeholderFont);
+	s.writeBE(placeholderFontSize);
+
+	using namespace coreinit;
+	ci_CodeGen_Save(s);
+	ci_DynLoad_Save(s);
+	ci_FG_Save(s);
+	ci_GHS_Save(s);
+	ci_IPC_Save(s);
+	ci_LockedCache_Save(s);
+	ci_MEM_Save(s);
+	ci_MemoryMapping_Save(s);
+	ci_MessageQueue_Save(s);
+	ci_OverlayArena_Save(s);
+	ci_Sync_Save(s);
+	ci_SysHeap_Save(s);
+	ci_SystemInfo_Save(s);
+}
+
+void ci_Restore(MemStreamReader& s)
+{
+	char section[16] = { '\0' };
+	s.readData(section, 15);
+	cemu_assert_debug(strcmp(section, "ci_S") == 0);
+
+	s.readData(gCoreinitData, sizeof(coreinitData_t));
+	placeholderFont = s.readBE<MPTR>();
+	placeholderFontSize = s.readBE<sint32>();
+
+	using namespace coreinit;
+	ci_CodeGen_Restore(s);
+	ci_DynLoad_Restore(s);
+	ci_FG_Restore(s);
+	ci_GHS_Restore(s);
+	ci_IPC_Restore(s);
+	ci_LockedCache_Restore(s);
+	ci_MEM_Restore(s);
+	ci_MemoryMapping_Restore(s);
+	ci_MessageQueue_Restore(s);
+	ci_OverlayArena_Restore(s);
+	ci_Sync_Restore(s);
+	ci_SysHeap_Restore(s);
+	ci_SystemInfo_Restore(s);
+}
+
 void coreinit_load()
 {
 	coreinit::InitializeCore();

src/Cafe/OS/libs/coreinit/coreinit.h

@@ -11,10 +11,16 @@ void InitializeAsyncCallback();
 void coreinitAsyncCallback_add(MPTR functionMPTR, uint32 numParameters, uint32 r3 = 0, uint32 r4 = 0, uint32 r5 = 0, uint32 r6 = 0, uint32 r7 = 0, uint32 r8 = 0, uint32 r9 = 0, uint32 r10 = 0);
 void coreinitAsyncCallback_addWithLock(MPTR functionMPTR, uint32 numParameters, uint32 r3 = 0, uint32 r4 = 0, uint32 r5 = 0, uint32 r6 = 0, uint32 r7 = 0, uint32 r8 = 0, uint32 r9 = 0, uint32 r10 = 0);
 
+void ci_Callbacks_Save(MemStreamWriter& s);
+void ci_Callbacks_Restore(MemStreamReader& s);
+
 // misc
 
 void coreinit_load();
 
+void ci_Save(MemStreamWriter& s);
+void ci_Restore(MemStreamReader& s);
+
 // coreinit shared memory
 
 typedef struct  
@@ -35,6 +41,9 @@ extern coreinitData_t* gCoreinitData;
 // coreinit init
 void coreinit_start(PPCInterpreter_t* hCPU);
 
+void ci_Init_Save(MemStreamWriter& s);
+void ci_Init_Restore(MemStreamReader& s);
+
 MPTR OSAllocFromSystem(uint32 size, uint32 alignment);
 void OSFreeToSystem(MPTR mem);
 

src/Cafe/OS/libs/coreinit/coreinit_Alarm.cpp

@@ -247,7 +247,7 @@ namespace coreinit
 		}
 		else
 		{
-			alarm->nextTime = _swapEndianU64(startTime);
+			alarm->nextTime = _swapEndianU64(nextTime);
 			alarm->period = 0;
 			alarm->handler = _swapEndianU32(handlerFunc);
 		}
@@ -305,6 +305,70 @@ namespace coreinit
         __OSUnlockScheduler();
 	}
 
+	void ci_Alarm_Save(MemStreamWriter& s)
+	{
+		s.writeData("ci_A_S", 15);
+
+		s.writeBE(g_alarmEvent.GetMPTR());
+		s.writeBE(g_alarmThread.GetMPTR());
+		s.writeBE(_g_alarmThreadStack.GetMPTR());
+		s.writeBE(_g_alarmThreadName.GetMPTR());
+
+		s.writeBE(coreinit_getOSTime());
+
+		s.writeBE(g_activeAlarms.size());
+		for (auto& itr : g_activeAlarms)
+		{
+			s.writeBE(memory_getVirtualOffsetFromPointer(itr.first));
+			s.writeBE(itr.second->getNextFire());
+		}
+	}
+
+	void ci_Alarm_Restore(MemStreamReader& s)
+	{
+		OSAlarm_Shutdown();
+
+		char section[16] = { '\0' };
+		s.readData(section, 15);
+		cemu_assert_debug(strcmp(section, "ci_A_S") == 0);
+
+		g_alarmEvent = (OSEvent*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+		g_alarmThread = (OSThread_t*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+		_g_alarmThreadStack = (uint8*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+		_g_alarmThreadName = (char*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+
+		uint64 currentTime = coreinit_getOSTime();
+		uint64_t timeOffset = currentTime - s.readBE<uint64_t>();
+
+		size_t alms = s.readBE<size_t>();
+		for (size_t alm = 0; alm < alms; alm++)
+		{
+			OSAlarm_t* alarm = (OSAlarm_t*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+
+			uint64 startTime = _swapEndianU64(alarm->startTime) + timeOffset;
+			uint64 nextTime = _swapEndianU64(alarm->nextTime) + timeOffset;
+			//uint64 nextTime = startTime;
+
+			uint64 period = _swapEndianU64(alarm->period);
+
+			if (period != 0)
+			{
+				//uint64 ticksSinceStart = currentTime - startTime;
+				//uint64 numPeriods = ticksSinceStart / period;
+			
+				//nextTime = startTime + (numPeriods + 1ull) * period;
+			
+				alarm->startTime = _swapEndianU64(startTime);
+			}
+			alarm->nextTime = _swapEndianU64(nextTime);
+
+			uint64 nextFire = s.readBE<uint64>() + timeOffset;
+			__OSLockScheduler();
+			g_activeAlarms[alarm] = OSHostAlarmCreate(nextFire, period, __OSHostAlarmTriggered, nullptr);
+			__OSUnlockScheduler();
+		}
+	}
+
 	void _OSAlarmThread(PPCInterpreter_t* hCPU)
 	{
 		while( true )

src/Cafe/OS/libs/coreinit/coreinit_Alarm.h

@@ -47,6 +47,9 @@ namespace coreinit
 
 	void OSAlarm_Shutdown();
 
+	void ci_Alarm_Save(MemStreamWriter& s);
+	void ci_Alarm_Restore(MemStreamReader& s);
+
 	void alarm_update();
 
 	void InitializeAlarm();

src/Cafe/OS/libs/coreinit/coreinit_Callbacks.cpp

@@ -31,6 +31,19 @@ struct CoreinitAsyncCallback
 		s_asyncCallbackSpinlock.unlock();
 	}
 
+	static std::vector<struct CoreinitAsyncCallback*>* getPoolPtr()
+	{
+		return &s_asyncCallbackPool;
+	}
+
+	static std::vector<struct CoreinitAsyncCallback*>* getQueuePtr()
+	{
+		return &s_asyncCallbackQueue;
+	}
+
+	friend void ci_Callbacks_Save(MemStreamWriter& s);
+	friend void ci_Callbacks_Restore(MemStreamReader& s);
+
 private:
 	void doCall()
 	{
@@ -104,6 +117,50 @@ void coreinitAsyncCallback_add(MPTR functionMPTR, uint32 numParameters, uint32 r
 	coreinitAsyncCallback_addWithLock(functionMPTR, numParameters, r3, r4, r5, r6, r7, r8, r9, r10);
 }
 
+void ci_Callbacks_Save(MemStreamWriter& s)
+{
+	s.writeData("ci_C_S", 15);
+
+	s.writeBE(g_coreinitCallbackThread.GetMPTR());
+	s.writeBE(_g_coreinitCallbackThreadStack.GetMPTR());
+	s.writeBE(g_asyncCallbackAsync.GetMPTR());
+	s.writeBE(_g_coreinitCBThreadName.GetMPTR());
+
+	std::vector<struct CoreinitAsyncCallback*>* pool = CoreinitAsyncCallback::getPoolPtr();
+	size_t poolSize = pool->size();
+	s.writeBE(poolSize);
+	s.writeData(pool, sizeof(CoreinitAsyncCallback) * poolSize);
+
+	std::vector<struct CoreinitAsyncCallback*>* queue = CoreinitAsyncCallback::getQueuePtr();
+	size_t queueSize = queue->size();
+	s.writeBE(queueSize);
+	s.writeData(queue, sizeof(CoreinitAsyncCallback) * queueSize);
+}
+
+void ci_Callbacks_Restore(MemStreamReader& s)
+{
+	char section[16] = { '\0' };
+	s.readData(section, 15);
+	cemu_assert_debug(strcmp(section, "ci_C_S") == 0);
+
+	g_coreinitCallbackThread = (OSThread_t*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+	_g_coreinitCallbackThreadStack = (uint8*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+	g_asyncCallbackAsync = (coreinit::OSSemaphore*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+	_g_coreinitCBThreadName = (char*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+
+	std::vector<struct CoreinitAsyncCallback*>* pool = CoreinitAsyncCallback::getPoolPtr();
+	size_t poolSize = s.readBE<size_t>();
+	pool->clear();
+	pool->resize(poolSize);
+	s.readData(pool, sizeof(CoreinitAsyncCallback) * poolSize);
+
+	std::vector<struct CoreinitAsyncCallback*>* queue = CoreinitAsyncCallback::getPoolPtr();
+	size_t queueSize = s.readBE<size_t>();
+	queue->clear();
+	queue->resize(queueSize);
+	s.readData(queue, sizeof(CoreinitAsyncCallback) * queueSize);
+}
+
 void InitializeAsyncCallback()
 {
 	coreinit::OSInitSemaphore(g_asyncCallbackAsync.GetPtr(), 0);

src/Cafe/OS/libs/coreinit/coreinit_CodeGen.cpp

@@ -136,6 +136,21 @@ namespace coreinit
 		return true;
 	}
 
+	void ci_CodeGen_Save(MemStreamWriter& s)
+	{
+		s.writeData("ci_CG_S", 15);
+		s.writeData(&coreinitCodeGen, sizeof(coreinitCodeGen));
+	}
+
+	void ci_CodeGen_Restore(MemStreamReader& s)
+	{
+		char section[16] = { '\0' };
+		s.readData(section, 15);
+		cemu_assert_debug(strcmp(section, "ci_CG_S") == 0);
+
+		s.readData(&coreinitCodeGen, sizeof(coreinitCodeGen));
+	}
+
 	void InitializeCodeGen()
 	{
 		cafeExportRegister("coreinit", OSGetCodegenVirtAddrRange, LogType::Placeholder);

src/Cafe/OS/libs/coreinit/coreinit_CodeGen.h

@@ -6,5 +6,8 @@ namespace coreinit
 	void codeGenHandleICBI(uint32 ea);
 	bool codeGenShouldAvoid();
 
+	void ci_CodeGen_Save(MemStreamWriter& s);
+	void ci_CodeGen_Restore(MemStreamReader& s);
+
 	void InitializeCodeGen();
 }

src/Cafe/OS/libs/coreinit/coreinit_DynLoad.cpp

@@ -129,6 +129,28 @@ namespace coreinit
 		return 0;
 	}
 
+	void ci_DynLoad_Save(MemStreamWriter& s)
+	{
+		s.writeData("ci_DL_S", 15);
+
+		s.writeBE(_osDynLoadFuncAlloc);
+		s.writeBE(_osDynLoadFuncFree);
+		s.writeBE(_osDynLoadTLSFuncAlloc);
+		s.writeBE(_osDynLoadTLSFuncFree);
+	}
+
+	void ci_DynLoad_Restore(MemStreamReader& s)
+	{
+		char section[16] = { '\0' };
+		s.readData(section, 15);
+		cemu_assert_debug(strcmp(section, "ci_DL_S") == 0);
+
+		_osDynLoadFuncAlloc = s.readBE<MPTR>();
+		_osDynLoadFuncFree = s.readBE<MPTR>();
+		_osDynLoadTLSFuncAlloc = s.readBE<MPTR>();
+		_osDynLoadTLSFuncFree = s.readBE<MPTR>();
+	}
+
 	void InitializeDynLoad()
 	{
 		cafeExportRegister("coreinit", OSDynLoad_SetAllocator, LogType::Placeholder);

src/Cafe/OS/libs/coreinit/coreinit_DynLoad.h

@@ -14,5 +14,8 @@ namespace coreinit
 	void OSDynLoad_Release(uint32 moduleHandle);
 	uint32 OSDynLoad_FindExport(uint32 moduleHandle, uint32 isData, const char* exportName, betype<MPTR>* addrOut);
 
+	void ci_DynLoad_Save(MemStreamWriter& s);
+	void ci_DynLoad_Restore(MemStreamReader& s);
+
 	void InitializeDynLoad();
 }

src/Cafe/OS/libs/coreinit/coreinit_FG.cpp

@@ -191,6 +191,26 @@ namespace coreinit
 		osLib_returnFromFunction(hCPU, r ? 1 : 0);
 	}
 
+	void ci_FG_Save(MemStreamWriter& s)
+	{
+		s.writeData("ci_FG_S", 15);
+
+		s.writeBE(fgAddr.GetMPTR());
+		s.writeBE(fgSaveAreaAddr.GetMPTR());
+		s.writeData(&fgAreaEntries, sizeof(fgAreaEntries) * FG_BUCKET_AREA_COUNT);
+	}
+
+	void ci_FG_Restore(MemStreamReader& s)
+	{
+		char section[16] = { '\0' };
+		s.readData(section, 15);
+		cemu_assert_debug(strcmp(section, "ci_FG_S") == 0);
+
+		fgAddr = memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+		fgSaveAreaAddr = memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+		s.readData(&fgAreaEntries, sizeof(fgAreaEntries) * FG_BUCKET_AREA_COUNT);
+	}
+
 	void InitializeFG()
 	{
 		osLib_addFunction("coreinit", "OSGetForegroundBucket", coreinitExport_OSGetForegroundBucket);

src/Cafe/OS/libs/coreinit/coreinit_FG.h

@@ -13,5 +13,8 @@ namespace coreinit
 
 	void InitForegroundBucket();
 
+	void ci_FG_Save(MemStreamWriter& s);
+	void ci_FG_Restore(MemStreamReader& s);
+
 	void InitializeFG();
 }

src/Cafe/OS/libs/coreinit/coreinit_FS.cpp

@@ -2638,14 +2638,38 @@ namespace coreinit
 		return FSA_RESULT::OK;
 	}
 
-	void FSSave(MemStreamWriter& s)
+	void ci_FS_Save(MemStreamWriter& s)
 	{
+		s.writeData("ci_FS_S", 15);
 		s.writeData(g_fsRegisteredClientBodies, sizeof(FSClientBody_t));
+		s.writeBE(_sdCard01Mounted);
+		s.writeBE(_mlc01Mounted);
+		s.writeBE(_tempFSSpace.GetMPTR());
+		size_t s_fsa_activeClients_size = s_fsa_activeClients.size();
+		s.writeBE(s_fsa_activeClients_size);
+		s.writeData(&s_fsa_activeClients, sizeof(FSAClientHandle) * s_fsa_activeClients_size);
+		s.writeBE(s_fsaIpcPool.GetMPTR());
+		s.writeBE(s_fsaIpcPoolBuffer.GetMPTR());
+		s.writeBE(s_fsaIpcPoolBufferNumItems.GetMPTR());
 	}
 
-	void FSRestore(MemStreamReader& s)
+	void ci_FS_Restore(MemStreamReader& s)
 	{
+		char section[16] = { '\0' };
+		s.readData(section, 15);
+		cemu_assert_debug(strcmp(section, "ci_FS_S") == 0);
+
 		s.readData(g_fsRegisteredClientBodies, sizeof(FSClientBody_t));
+		_sdCard01Mounted = s.readBE<bool>();
+		_mlc01Mounted = s.readBE<bool>();
+		_tempFSSpace = memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+		size_t s_fsa_activeClients_size = s.readBE<size_t>();
+		s_fsa_activeClients.clear();
+		s_fsa_activeClients.resize(s_fsa_activeClients_size);
+		s.readData(&s_fsa_activeClients, sizeof(FSAClientHandle) * s_fsa_activeClients_size);
+		s_fsaIpcPool = (IPCBufPool_t*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+		s_fsaIpcPoolBuffer = memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+		s_fsaIpcPoolBufferNumItems = (uint32be*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
 	}
 
 	void InitializeFS()

src/Cafe/OS/libs/coreinit/coreinit_FS.h

@@ -308,8 +308,8 @@ namespace coreinit
 
 	FS_VOLSTATE FSGetVolumeState(FSClient_t* fsClient);
 
-	void FSSave(MemStreamWriter& s);
+	void ci_FS_Save(MemStreamWriter& s);
-	void FSRestore(MemStreamReader& s);
+	void ci_FS_Restore(MemStreamReader& s);
 
 	void InitializeFS();
 }; // namespace coreinit

src/Cafe/OS/libs/coreinit/coreinit_GHS.cpp

@@ -258,6 +258,26 @@ namespace coreinit
 		return memory_getPointerFromVirtualOffset(_swapEndianU32(tlsBlock->addr) + _swapEndianU32(tlsIndex->ukn04));
 	}
 
+	void ci_GHS_Save(MemStreamWriter& s)
+	{
+		s.writeData("ci_GHS_S", 15);
+
+		s.writeBE(g_ghs_data.GetMPTR());
+		s.writeBE(_flockMutexArray.GetMPTR());
+		s.writeData(_flockMutexMask, sizeof(bool) * GHS_FOPEN_MAX);
+	}
+
+	void ci_GHS_Restore(MemStreamReader& s)
+	{
+		char section[16] = { '\0' };
+		s.readData(section, 15);
+		cemu_assert_debug(strcmp(section, "ci_GHS_S") == 0);
+
+		g_ghs_data = (GHSAccessibleData*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+		_flockMutexArray = (coreinit::OSMutex*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+		s.readData(_flockMutexMask, sizeof(bool) * GHS_FOPEN_MAX);
+	}
+
 	void InitializeGHS()
 	{
 		cafeExportRegister("coreinit", __ghs_flock_create, LogType::Placeholder);

src/Cafe/OS/libs/coreinit/coreinit_GHS.h

@@ -4,5 +4,8 @@ namespace coreinit
 {
 	void PrepareGHSRuntime();
 
+	void ci_GHS_Save(MemStreamWriter& s);
+	void ci_GHS_Restore(MemStreamReader& s);
+
 	void InitializeGHS();
 };

src/Cafe/OS/libs/coreinit/coreinit_IPC.cpp

@@ -462,6 +462,34 @@ namespace coreinit
 		return r;
 	}
 
+	void ci_IPC_Save(MemStreamWriter& s)
+	{
+		s.writeData("ci_IPC_S", 15);
+
+		s.writeBE(s_ipcResourceBuffers.GetMPTR());
+		s.writeBE(s_ipcDriver.GetMPTR());
+		s.writeBE(gIPCThread.GetMPTR());
+		s.writeBE(_gIPCThreadStack.GetMPTR());
+		s.writeBE(_gIPCThreadNameStorage.GetMPTR());
+		s.writeBE(gIPCThreadMsgQueue.GetMPTR());
+		s.writeBE(_gIPCThreadSemaphoreStorage.GetMPTR());
+	}
+
+	void ci_IPC_Restore(MemStreamReader& s)
+	{
+		char section[16] = { '\0' };
+		s.readData(section, 15);
+		cemu_assert_debug(strcmp(section, "ci_IPC_S") == 0);
+
+		s_ipcResourceBuffers = (IPCResourceBuffer*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+		s_ipcDriver = (IPCDriver*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+		gIPCThread = (OSThread_t*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+		_gIPCThreadStack = memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+		_gIPCThreadNameStorage = memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+		gIPCThreadMsgQueue = (OSMessageQueue*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+		_gIPCThreadSemaphoreStorage = (OSMessage*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+	}
+
 	void InitializeIPC()
 	{
 		for (uint32 i = 0; i < Espresso::CORE_COUNT; i++)
@@ -478,5 +506,4 @@ namespace coreinit
 		cafeExportRegister("coreinit", IOS_Ioctlv, LogType::PPC_IPC);
 		cafeExportRegister("coreinit", IOS_IoctlvAsync, LogType::PPC_IPC);
 	}
-
 };

src/Cafe/OS/libs/coreinit/coreinit_IPC.h

@@ -12,5 +12,8 @@ namespace coreinit
 	IOS_ERROR IOS_Ioctlv(IOSDevHandle devHandle, uint32 requestId, uint32 numIn, uint32 numOut, IPCIoctlVector* vec);
 	IOS_ERROR IOS_IoctlvAsync(IOSDevHandle devHandle, uint32 requestId, uint32 numIn, uint32 numOut, IPCIoctlVector* vec, MEMPTR<void> asyncResultFunc, MEMPTR<void> asyncResultUserParam);
 
+	void ci_IPC_Save(MemStreamWriter& s);
+	void ci_IPC_Restore(MemStreamReader& s);
+
 	void InitializeIPC();
 };

src/Cafe/OS/libs/coreinit/coreinit_Init.cpp

@@ -215,3 +215,25 @@ void coreinit_start(PPCInterpreter_t* hCPU)
 	hCPU->gpr[3] = _coreinitInfo->argc;
 	hCPU->instructionPointer = _coreinitTitleEntryPoint;
 }
+
+void ci_Init_Save(MemStreamWriter& s)
+{
+	s.writeData("ci_Init_S", 15);
+
+	s.writeData(_coreinitInfo, sizeof(coreinitInit_t));
+	s.writeBE(argStorageIndex);
+	s.writeBE(g_preinitUserParam.GetMPTR());
+	s.writeBE(_coreinitTitleEntryPoint);
+}
+
+void ci_Init_Restore(MemStreamReader& s)
+{
+	char section[16] = { '\0' };
+	s.readData(section, 15);
+	cemu_assert_debug(strcmp(section, "ci_Init_S") == 0);
+
+	s.readData(_coreinitInfo, sizeof(coreinitInit_t));
+	argStorageIndex = s.readBE<sint32>();
+	g_preinitUserParam = (PreinitUserHeapStruct*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+	_coreinitTitleEntryPoint = s.readBE<sint32>();
+}

src/Cafe/OS/libs/coreinit/coreinit_LockedCache.cpp

@@ -271,6 +271,26 @@ namespace coreinit
 		osLib_returnFromFunction(hCPU, 0);
 	}
 
+	void ci_LockedCache_Save(MemStreamWriter& s)
+	{
+		s.writeData("ci_LC_S", 15);
+
+		s.writeData(lcCacheMask, sizeof(uint8) * PPC_CORE_COUNT * (LC_LOCKED_CACHE_SIZE + LC_LOCKED_CACHE_GRANULARITY - 1) / LC_LOCKED_CACHE_GRANULARITY);
+		s.writeData(lcAllocatedBlocks, sizeof(uint32) * PPC_CORE_COUNT);
+		s.writeBE(_lcDisableErrorCounter);
+	}
+
+	void ci_LockedCache_Restore(MemStreamReader& s)
+	{
+		char section[16] = { '\0' };
+		s.readData(section, 15);
+		cemu_assert_debug(strcmp(section, "ci_LC_S") == 0);
+
+		s.readData(lcCacheMask, sizeof(uint8) * PPC_CORE_COUNT * (LC_LOCKED_CACHE_SIZE + LC_LOCKED_CACHE_GRANULARITY - 1) / LC_LOCKED_CACHE_GRANULARITY);
+		s.readData(lcAllocatedBlocks, sizeof(uint32) * PPC_CORE_COUNT);
+		_lcDisableErrorCounter = s.readBE<sint32>();
+	}
+
 	void InitializeLC()
 	{
 		for (sint32 f = 0; f < PPC_CORE_COUNT; f++)

src/Cafe/OS/libs/coreinit/coreinit_LockedCache.h

@@ -2,5 +2,8 @@
 
 namespace coreinit
 {
+	void ci_LockedCache_Save(MemStreamWriter& s);
+	void ci_LockedCache_Restore(MemStreamReader& s);
+
 	void InitializeLC();
 }

src/Cafe/OS/libs/coreinit/coreinit_MEM.cpp

@@ -630,6 +630,46 @@ namespace coreinit
         memset(&g_list3, 0, sizeof(g_list3));
     }
 
+	void ci_MEM_Save(MemStreamWriter& s)
+	{
+		s.writeData("ci_MEM_S", 15);
+
+		s.writeBE(sysAreaAllocatorOffset);
+		s.writeBE(g_heapTableCount);
+		s.writeData(g_heapTable, sizeof(MEMHeapBase) * MEM_MAX_HEAP_TABLE);
+		s.writeBE(g_slockInitialized);
+		s.writeBE(g_listsInitialized);
+		s.writeData(&g_list1, sizeof(MEMList));
+		s.writeData(&g_list2, sizeof(MEMList));
+		s.writeData(&g_list3, sizeof(MEMList));
+		s.writeData(&gHeapFillValues, sizeof(uint32) * 3);
+		s.writeBE(gHeapGlobalLock.GetMPTR());
+		s.writeData(&gDefaultHeap, sizeof(MEMHeapBase));
+		s.writeData(&sHeapBaseHandle, sizeof(MEMHeapBase) * 9);
+		s.writeBE(gDefaultHeapAllocator.GetMPTR());
+	}
+
+	void ci_MEM_Restore(MemStreamReader& s)
+	{
+		char section[16] = { '\0' };
+		s.readData(section, 15);
+		cemu_assert_debug(strcmp(section, "ci_MEM_S") == 0);
+
+		sysAreaAllocatorOffset = s.readBE<MPTR>();
+		g_heapTableCount = s.readBE<sint32>();
+		s.readData(g_heapTable, sizeof(MEMHeapBase) * MEM_MAX_HEAP_TABLE);
+		g_slockInitialized = s.readBE<bool>();
+		g_listsInitialized = s.readBE<bool>();
+		s.readData(&g_list1, sizeof(MEMList));
+		s.readData(&g_list2, sizeof(MEMList));
+		s.readData(&g_list3, sizeof(MEMList));
+		s.readData(&gHeapFillValues, sizeof(uint32) * 3);
+		gHeapGlobalLock = (OSSpinLock*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+		s.readData(&gDefaultHeap, sizeof(MEMHeapBase));
+		s.readData(&sHeapBaseHandle, sizeof(MEMHeapBase) * 9);
+		gDefaultHeapAllocator = (MEMAllocatorFunc*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+	}
+
 	void InitializeMEM()
 	{
         MEMResetToDefaultState();

src/Cafe/OS/libs/coreinit/coreinit_MEM.h

@@ -179,5 +179,8 @@ namespace coreinit
 
 	void InitializeMEMUnitHeap();
 
+	void ci_MEM_Save(MemStreamWriter& s);
+	void ci_MEM_Restore(MemStreamReader& s);
+
 	void InitializeMEM();
 }

src/Cafe/OS/libs/coreinit/coreinit_MemoryMapping.cpp

@@ -16,6 +16,8 @@ namespace coreinit
 
 	struct OSVirtMemoryEntry
 	{
+		OSVirtMemoryEntry() : virtualAddress(0), size(0), alignment(0) {};
+
 		OSVirtMemoryEntry(MPTR virtualAddress, uint32 size, uint32 alignment) : virtualAddress(virtualAddress), size(size), alignment(alignment) {};
 
 		MPTR virtualAddress;
@@ -151,6 +153,27 @@ namespace coreinit
 		return 1;
 	}
 
+	void ci_MemoryMapping_Save(MemStreamWriter& s)
+	{
+		s.writeData("ci_MemMap_S", 15);
+		
+		size_t s_allocatedVirtMemorySize = s_allocatedVirtMemory.size();
+		s.writeBE(s_allocatedVirtMemorySize);
+		s.writeData(&s_allocatedVirtMemory, sizeof(OSVirtMemoryEntry) * s_allocatedVirtMemorySize);
+	}
+
+	void ci_MemoryMapping_Restore(MemStreamReader& s)
+	{
+		char section[16] = { '\0' };
+		s.readData(section, 15);
+		cemu_assert_debug(strcmp(section, "ci_MemMap_S") == 0);
+
+		size_t s_allocatedVirtMemorySize = s.readBE<size_t>();
+		s_allocatedVirtMemory.clear();
+		s_allocatedVirtMemory.resize(s_allocatedVirtMemorySize);
+		s.readData(&s_allocatedVirtMemory, sizeof(OSVirtMemoryEntry) * s_allocatedVirtMemorySize);
+	}
+
 	void InitializeMemoryMapping()
 	{
 		s_allocatedVirtMemory.clear();

src/Cafe/OS/libs/coreinit/coreinit_MemoryMapping.h

@@ -1,5 +1,8 @@
 
 namespace coreinit
 {
+	void ci_MemoryMapping_Save(MemStreamWriter& s);
+	void ci_MemoryMapping_Restore(MemStreamReader& s);
+
 	void InitializeMemoryMapping();
 }

src/Cafe/OS/libs/coreinit/coreinit_MessageQueue.cpp

@@ -117,6 +117,24 @@ namespace coreinit
 		return g_systemMessageQueue.GetPtr();
 	}
 
+	void ci_MessageQueue_Save(MemStreamWriter& s)
+	{
+		s.writeData("ci_MessQue_S", 15);
+
+		s.writeBE(g_systemMessageQueue.GetMPTR());
+		s.writeBE(_systemMessageQueueArray.GetMPTR());
+	}
+
+	void ci_MessageQueue_Restore(MemStreamReader& s)
+	{
+		char section[16] = { '\0' };
+		s.readData(section, 15);
+		cemu_assert_debug(strcmp(section, "ci_MessQue_S") == 0);
+
+		g_systemMessageQueue = (OSMessageQueue*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+		_systemMessageQueueArray = (OSMessage*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+	}
+
 	void InitializeMessageQueue()
 	{
 		OSInitMessageQueue(g_systemMessageQueue.GetPtr(), _systemMessageQueueArray.GetPtr(), _systemMessageQueueArray.GetCount());

src/Cafe/OS/libs/coreinit/coreinit_MessageQueue.h

@@ -36,5 +36,8 @@ namespace coreinit
 	bool OSPeekMessage(OSMessageQueue* msgQueue, OSMessage* msg);
 	sint32 OSSendMessage(OSMessageQueue* msgQueue, OSMessage* msg, uint32 flags);
 
+	void ci_MessageQueue_Save(MemStreamWriter& s);
+	void ci_MessageQueue_Restore(MemStreamReader& s);
+
 	void InitializeMessageQueue();
 };

src/Cafe/OS/libs/coreinit/coreinit_OverlayArena.cpp

@@ -25,6 +25,21 @@ namespace coreinit
 		*areaSize = MEMORY_OVERLAY_AREA_SIZE;
 	}
 
+	void ci_OverlayArena_Save(MemStreamWriter& s)
+	{
+		s.writeData("ci_OverArea_S", 15);
+
+		s.writeData(&g_coreinitOverlayArena, sizeof(g_coreinitOverlayArena));
+	}
+	void ci_OverlayArena_Restore(MemStreamReader& s)
+	{
+		char section[16] = { '\0' };
+		s.readData(section, 15);
+		cemu_assert_debug(strcmp(section, "ci_OverArea_S") == 0);
+
+		s.readData(&g_coreinitOverlayArena, sizeof(g_coreinitOverlayArena));
+	}
+
 	void InitializeOverlayArena()
 	{
 		cafeExportRegister("coreinit", OSIsEnabledOverlayArena, LogType::Placeholder);

src/Cafe/OS/libs/coreinit/coreinit_OverlayArena.h

@@ -1,4 +1,7 @@
 namespace coreinit
 {
+	void ci_OverlayArena_Save(MemStreamWriter& s);
+	void ci_OverlayArena_Restore(MemStreamReader& s);
+
 	void InitializeOverlayArena();
 };

src/Cafe/OS/libs/coreinit/coreinit_Synchronization.cpp

@@ -614,6 +614,22 @@ namespace coreinit
 		OSWakeupThread(&fastCond->threadQueue);
 	}
 
+	void ci_Sync_Save(MemStreamWriter& s)
+	{
+		s.writeData("ci_Sync_S", 15);
+
+		s.writeBE(g_rendezvousEvent.GetMPTR());
+	}
+
+	void ci_Sync_Restore(MemStreamReader& s)
+	{
+		char section[16] = { '\0' };
+		s.readData(section, 15);
+		cemu_assert_debug(strcmp(section, "ci_Sync_S") == 0);
+
+		g_rendezvousEvent = (OSEvent*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+	}
+
 	/************* init ************/
 
 	void InitializeConcurrency()

src/Cafe/OS/libs/coreinit/coreinit_SysHeap.cpp

@@ -32,6 +32,26 @@ namespace coreinit
 		_sysHeapFreeCounter = 0;
 	}
 
+	void ci_SysHeap_Save(MemStreamWriter& s)
+	{
+		s.writeData("ci_SysHeap_S", 15);
+
+		s.writeData(_sysHeapHandle, sizeof(MEMHeapBase));
+		s.writeBE(_sysHeapAllocCounter);
+		s.writeBE(_sysHeapFreeCounter);
+	}
+
+	void ci_SysHeap_Restore(MemStreamReader& s)
+	{
+		char section[16] = { '\0' };
+		s.readData(section, 15);
+		cemu_assert_debug(strcmp(section, "ci_SysHeap_S") == 0);
+
+		s.readData(_sysHeapHandle, sizeof(MEMHeapBase));
+		_sysHeapAllocCounter = s.readBE<sint32>();
+		_sysHeapFreeCounter = s.readBE<sint32>();
+	}
+
 	void InitializeSysHeap()
 	{
 		osLib_addFunction("coreinit", "OSAllocFromSystem", export_OSAllocFromSystem);

src/Cafe/OS/libs/coreinit/coreinit_SysHeap.h

@@ -4,5 +4,8 @@ namespace coreinit
 {
 	void InitSysHeap();
 
+	void ci_SysHeap_Save(MemStreamWriter& s);
+	void ci_SysHeap_Restore(MemStreamReader& s);
+
 	void InitializeSysHeap();
 }

src/Cafe/OS/libs/coreinit/coreinit_SystemInfo.cpp

@@ -10,6 +10,22 @@ namespace coreinit
 		return *g_system_info.GetPtr();
 	}
 
+	void ci_SystemInfo_Save(MemStreamWriter& s)
+	{
+		s.writeData("ci_SysInfo_S", 15);
+
+		s.writeBE(g_system_info.GetMPTR());
+	}
+
+	void ci_SystemInfo_Restore(MemStreamReader& s)
+	{
+		char section[16] = { '\0' };
+		s.readData(section, 15);
+		cemu_assert_debug(strcmp(section, "ci_SysInfo_S") == 0);
+
+		g_system_info = (OSSystemInfo*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+	}
+
 	void InitializeSystemInfo()
 	{
 		cemu_assert(ppcCyclesSince2000 != 0);

src/Cafe/OS/libs/coreinit/coreinit_SystemInfo.h

@@ -16,6 +16,9 @@ namespace coreinit
 
 	const OSSystemInfo& OSGetSystemInfo();
 	
+	void ci_SystemInfo_Save(MemStreamWriter& s);
+	void ci_SystemInfo_Restore(MemStreamReader& s);
+
 	void InitializeSystemInfo();
 };
 

src/Cafe/OS/libs/coreinit/coreinit_Thread.cpp

@@ -196,36 +196,6 @@ namespace coreinit
 		return __currentCoreThread[currentInstance->spr.UPIR];
 	}
 
-	void SuspendAllThreads()
-	{
-		for (auto& thr : activeThread)
-		{
-			auto* ptr = (OSThread_t*)memory_getPointerFromVirtualOffset(thr);
-			if (thr != 0)
-			{
-				OSSuspendThread(ptr);
-			}
-		}
-	}
-
-	void ResumeAllThreads()
-	{
-		for (auto& thr : activeThread)
-		{
-			auto* ptr = (OSThread_t*)memory_getPointerFromVirtualOffset(thr);
-			if (thr != 0)
-			{
-				if (s_threadToFiber.find(ptr) == s_threadToFiber.end())
-				{
-					__OSLockScheduler();
-					__OSCreateHostThread(ptr);
-					__OSUnlockScheduler();
-				}
-				OSResumeThread(ptr);
-			}
-		}
-	}
-
 	void threadEntry(PPCInterpreter_t* hCPU)
 	{
 		OSThread_t* currentThread = coreinitThread_getCurrentThreadDepr(hCPU);
@@ -1361,6 +1331,104 @@ namespace coreinit
 		}
 	}
 
+	void ci_Thread_Save(MemStreamWriter& s)
+	{
+		s.writeData("ci_T_S", 15);
+
+		s.writeBE(g_activeThreadQueue.GetMPTR());
+		s.writeBE(g_coreRunQueue.GetMPTR());
+
+		s.writeBE(activeThreadCount);
+		for (sint32 i = 0; i < activeThreadCount; i++)
+		{
+			s.writeBE(activeThread[i]);
+		}
+		for (sint32 i = 0; i < PPC_CORE_COUNT; i++)
+		{
+			s.writeBE(memory_getVirtualOffsetFromPointer(__currentCoreThread[i]));
+			s.writeBE(s_lehmer_lcg[i]);
+			s.writeBE(s_terminatorThreads[i].terminatorThread.GetMPTR());
+			s.writeBE(s_terminatorThreads[i].threadStack.GetMPTR());
+			s.writeBE(s_terminatorThreads[i].threadName.GetMPTR());
+			s.writeBE(s_terminatorThreads[i].semaphoreQueuedDeallocators.GetMPTR());
+		}
+		s.writeBE(s_defaultThreads.GetMPTR());
+		s.writeBE(s_stack.GetMPTR());
+	}
+
+	void ci_Thread_Restore(MemStreamReader& s, bool recreate)
+	{
+		char section[16] = { '\0' };
+		s.readData(section,15);
+		cemu_assert_debug(strcmp(section, "ci_T_S") == 0);
+
+		g_activeThreadQueue = (OSThreadQueue*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+		g_coreRunQueue = (OSThreadQueue*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+
+		sint32 prevActiveThreadCount = s.readBE<sint32>();
+		for (sint32 i = 0; i < prevActiveThreadCount; i++)
+		{
+			MPTR threadMPTR = s.readBE<MPTR>();
+			if (recreate)
+			{
+				__OSLockScheduler();
+				__OSActivateThread((OSThread_t*)memory_getPointerFromVirtualOffset(threadMPTR));
+				__OSUnlockScheduler();
+			}
+			else
+			{
+				activeThreadCount = prevActiveThreadCount;
+				activeThread[i] = threadMPTR;
+			}
+		}
+		for (sint32 i = 0; i < PPC_CORE_COUNT; i++)
+		{
+			__currentCoreThread[i] = (OSThread_t*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+			s_lehmer_lcg[i] = s.readBE<uint32>();
+			s_terminatorThreads[i].terminatorThread = (OSThread_t*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+			s_terminatorThreads[i].threadStack = (uint8*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+			s_terminatorThreads[i].threadName = (char*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+			s_terminatorThreads[i].semaphoreQueuedDeallocators = (OSSemaphore*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+		}
+		s_defaultThreads = (OSThread_t*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+		s_stack = (uint8*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+	}
+
+	void SuspendActiveThreads()
+	{
+
+		for (auto& thr : activeThread)
+		{
+			if (thr != MPTR_NULL)
+			{
+				auto* ptr = (OSThread_t*)memory_getPointerFromVirtualOffset(thr);
+				cemuLog_log(LogType::SaveStates, "Before State: {}", ptr->state.value());
+				cemuLog_log(LogType::SaveStates, "Before SusCnt: {}", ptr->suspendCounter);
+				OSSuspendThread(ptr);
+				cemuLog_log(LogType::SaveStates, "After State: {}", ptr->state.value());
+				cemuLog_log(LogType::SaveStates, "After SusCnt: {}", ptr->suspendCounter);
+			}
+		}
+	}
+
+	void ResumeActiveThreads()
+	{
+		for (auto& thr : activeThread)
+		{
+			if (thr != MPTR_NULL)
+			{
+				auto* ptr = (OSThread_t*)memory_getPointerFromVirtualOffset(thr);
+				if (s_threadToFiber.find(ptr) == s_threadToFiber.end())
+				{
+					__OSLockScheduler();
+					__OSCreateHostThread(ptr);
+					__OSUnlockScheduler();
+				}
+				OSResumeThread(ptr);
+			}
+		}
+	}
+
 	void InitializeThread()
 	{
 		cafeExportRegister("coreinit", OSCreateThreadType, LogType::CoreinitThread);

src/Cafe/OS/libs/coreinit/coreinit_Thread.h

@@ -496,7 +496,16 @@ static_assert(sizeof(OSThread_t) == 0x6A0-4); // todo - determine correct size
 
 namespace coreinit
 {
+	void ci_Thread_Save(MemStreamWriter& s);
+	void ci_Thread_Restore(MemStreamReader& s, bool recreate);
+	void SuspendActiveThreads();
+	void ResumeActiveThreads();
+
 	void InitializeThread();
+
+	void ci_Sync_Save(MemStreamWriter& s);
+	void ci_Sync_Restore(MemStreamReader& s);
+
 	void InitializeConcurrency();
 
 	bool __CemuIsMulticoreMode();
@@ -524,8 +533,6 @@ namespace coreinit
 
 	sint32 __OSResumeThreadInternal(OSThread_t* thread, sint32 resumeCount);
 	sint32 OSResumeThread(OSThread_t* thread);
-	void SuspendAllThreads();
-	void ResumeAllThreads();
 	void OSContinueThread(OSThread_t* thread);
 	void __OSSuspendThreadInternal(OSThread_t* thread);
 	void __OSSuspendThreadNolock(OSThread_t* thread);

src/Cemu/Logging/CemuLogging.h

@@ -35,6 +35,8 @@ enum class LogType : sint32
 
 	ProcUi = 40,
 
+	SaveStates = 50,
+
 	APIErrors = 0, // alias for Force. Logs bad parameters or other API errors in OS libs
 
 	

src/Common/SysAllocator.h

@@ -56,6 +56,12 @@ public:
 		m_tempData.insert(m_tempData.begin(), str, str + N);
 	}
 
+	SysAllocator& operator=(T* value)
+	{
+		m_sysMem = value;
+		return *this;
+	}
+
 	constexpr uint32 GetCount() const
 	{
 		return count;
@@ -165,6 +171,12 @@ public:
 		return *this;
 	}
 
+	SysAllocator& operator=(T* value)
+	{
+		m_sysMem = value;
+		return *this;
+	}
+
 	operator T()
 	{
 		return *GetPtr();

src/gui/MainWindow.cpp

@@ -2250,6 +2250,7 @@ void MainWindow::RecreateMenu()
 	debugLoggingMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + stdx::to_underlying(LogType::Patches), _("&Graphic pack patches"), wxEmptyString)->Check(cemuLog_isLoggingEnabled(LogType::Patches));
 	debugLoggingMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + stdx::to_underlying(LogType::TextureCache), _("&Texture cache warnings"), wxEmptyString)->Check(cemuLog_isLoggingEnabled(LogType::TextureCache));
 	debugLoggingMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + stdx::to_underlying(LogType::TextureReadback), _("&Texture readback"), wxEmptyString)->Check(cemuLog_isLoggingEnabled(LogType::TextureReadback));
+	debugLoggingMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + stdx::to_underlying(LogType::SaveStates), _("&Save states"), wxEmptyString)->Check(cemuLog_isLoggingEnabled(LogType::SaveStates));
 	debugLoggingMenu->AppendSeparator();
 	debugLoggingMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + stdx::to_underlying(LogType::OpenGLLogging), _("&OpenGL debug output"), wxEmptyString)->Check(cemuLog_isLoggingEnabled(LogType::OpenGLLogging));
 	debugLoggingMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + stdx::to_underlying(LogType::VulkanValidation), _("&Vulkan validation layer (slow)"), wxEmptyString)->Check(cemuLog_isLoggingEnabled(LogType::VulkanValidation));