Refactoring, save/restore additional libs

src/Cafe/CafeSystem.cpp

@@ -1007,13 +1007,10 @@ namespace CafeSystem
 		writer.writeData(LatteGPUState.contextRegister, sizeof(LatteGPUState.contextRegister));
 		writer.writeData(LatteGPUState.contextRegisterShadowAddr, sizeof(LatteGPUState.contextRegister));
 		writer.writeData(LatteGPUState.sharedArea, sizeof(gx2GPUSharedArea_t));
-		// cpu
+
-		ci_Save(writer);
+		nn::temp::save(writer);
-		coreinit::ci_Alarm_Save(writer);
+		nn::aoc::save(writer);
-		ci_Callbacks_Save(writer);
+		osLib_save(writer);
-		coreinit::ci_FS_Save(writer);
-		ci_Init_Save(writer);
-		coreinit::ci_Thread_Save(writer);
 		iosu::fsa::Save(writer);
 
 		FileStream* stream = FileStream::createFile(path);
@@ -1034,10 +1031,6 @@ namespace CafeSystem
 		assert(data.has_value());
 		MemStreamReader reader(data->data(), data->size());
 
-		bool recreate = false;
-		if (recreate)
-			coreinit::__OSDeleteAllActivePPCThreads();
-
 		// memory
 		DestroyMemorySpace();
 		memory_Deserialize(reader);
@@ -1045,13 +1038,10 @@ namespace CafeSystem
 		reader.readData(LatteGPUState.contextRegister, sizeof(LatteGPUState.contextRegister));
 		reader.readData(LatteGPUState.contextRegisterShadowAddr, sizeof(LatteGPUState.contextRegister));
 		reader.readData(LatteGPUState.sharedArea, sizeof(gx2GPUSharedArea_t));
-		// cpu
+
-		ci_Restore(reader);
+		nn::temp::restore(reader);
-		coreinit::ci_Alarm_Restore(reader);
+		nn::aoc::restore(reader);
-		ci_Callbacks_Restore(reader);
+		osLib_restore(reader);
-		coreinit::ci_FS_Restore(reader);
-		ci_Init_Restore(reader);
-		coreinit::ci_Thread_Restore(reader, recreate);
 		iosu::fsa::Restore(reader);
 
 		cemuLog_log(LogType::SaveStates, "Loaded state from {}.", path);

src/Cafe/Filesystem/fsc.cpp

@@ -285,8 +285,6 @@ FSCMountPathNode* fsc_lookupPathVirtualNode(const char* path, sint32 priority)
 class FSCVirtualFileDirectoryIterator : public FSCVirtualFile
 {
 public:
-	void Save(MemStreamWriter& writer) override;
-
 	sint32 fscGetType() override
 	{
 		return FSC_TYPE_DIRECTORY;
@@ -340,6 +338,8 @@ public:
 		dirIterator->dirEntries.emplace_back(dirEntry);
 	}
 
+	void Save(MemStreamWriter& writer) override;
+
 private:
 	void PopulateIterationList()
 	{
@@ -736,11 +736,39 @@ void fsc_init()
 	fsc_reset();
 }
 
+template <>
+void MemStreamWriter::writeBE<FSCVirtualFile::FSCDirIteratorState>(const FSCVirtualFile::FSCDirIteratorState& v)
+{
+	writeBE(v.index);
+	writePODVector(v.dirEntries);
+}
+
+template <>
+void MemStreamReader::readBE(FSCVirtualFile::FSCDirIteratorState& v)
+{
+	readBE(v.index);
+	readPODVector(v.dirEntries);
+}
+
 void FSCVirtualFile::Save(MemStreamWriter& writer)
 {
-	writer.writeBE(dirIterator != nullptr);
+	writer.writeBool(dirIterator != nullptr);
 	if (dirIterator) writer.writeBE(*dirIterator);
+	writer.writeBool(m_isAppend);
 }
+
+void FSCVirtualFileDirectoryIterator::Save(MemStreamWriter& writer)
+{
+	writer.writeBE<uint32>((uint32)Child::DIRECTORY_ITERATOR);
+	writer.writeBE(m_path);
+	writer.writeBE<uint32>(m_folders.size());
+	for (auto& folder : m_folders)
+	{
+		folder->Save(writer);
+	}
+	FSCVirtualFile::Save(writer);
+}
+
 #include "Cafe/Filesystem/fscDeviceHostFS.h"
 
 FSCVirtualFile* FSCVirtualFile::Restore(MemStreamReader& reader)
@@ -748,46 +776,35 @@ FSCVirtualFile* FSCVirtualFile::Restore(MemStreamReader& reader)
 	FSCVirtualFile* file;
 	switch ((Child)reader.readBE<uint32>())
 	{
-	case Child::DIRECTORY_ITERATOR:
+		case Child::DIRECTORY_ITERATOR:
-	{
-		std::string path = reader.readBE<std::string>();
-		std::vector<FSCVirtualFile*> folders{};
-		size_t size = reader.readBE<size_t>();
-		for (size_t i = 0; i < size; i++)
 		{
-			folders.push_back(Restore(reader));
+			std::string path = reader.readBE<std::string>();
+			std::vector<FSCVirtualFile*> folders{};
+			size_t size = reader.readBE<uint32>();
+			for (size_t i = 0; i < size; i++)
+			{
+				folders.push_back(Restore(reader));
+			}
+			file = new FSCVirtualFileDirectoryIterator(path, folders);
+			break;
 		}
-		file = new FSCVirtualFileDirectoryIterator(path, folders);
+		case Child::HOST:
-		break;
+		{
+			std::string path = reader.readBE<std::string>();
+			FSC_ACCESS_FLAG flags = (FSC_ACCESS_FLAG)reader.readBE<uint32>();
+			sint32 status{};
+			file = FSCVirtualFile_Host::OpenFile(path, flags, status);
+			file->fscSetSeek(reader.readBE<uint64>());
+			break;
+		}
+		default:
+			throw std::exception("Not implemented");
 	}
-	case Child::HOST:
+	if (reader.readBool())
-	{
-		std::string path = reader.readBE<std::string>();
-		FSC_ACCESS_FLAG flags = (FSC_ACCESS_FLAG)reader.readBE<uint32>();
-		sint32 status{};
-		file = FSCVirtualFile_Host::OpenFile(path, flags, status);
-		file->fscSetSeek(reader.readBE<uint64>());
-		break;
-	}
-	default:
-		throw std::exception("Not implemented");
-	}
-	if (reader.readBE<bool>())
 	{
 		file->dirIterator = new FSCDirIteratorState;
-		*file->dirIterator = reader.readBE<FSCDirIteratorState>();
+		reader.readBE(*file->dirIterator);
 	}
+	reader.readBool(file->m_isAppend);
 	return file;
-}
-
-void FSCVirtualFileDirectoryIterator::Save(MemStreamWriter& writer)
-{
-	writer.writeBE<uint32>((uint32)Child::DIRECTORY_ITERATOR);
-	writer.writeBE(m_path);
-	writer.writeBE(m_folders.size());
-	for (auto& folder : m_folders)
-	{
-		folder->Save(writer);
-	}
-	FSCVirtualFile::Save(writer);
 }

src/Cafe/Filesystem/fsc.h

@@ -38,7 +38,6 @@ DEFINE_ENUM_FLAG_OPERATORS(FSC_ACCESS_FLAG);
 #define FSC_STATUS_ALREADY_EXISTS		(3)
 // note: Unlike the native Wii U filesystem, FSC does not provide separate error codes for NOT_A_FILE and NOT_A_DIRECTORY
 // to determine them manually, open with both modes (file and dir) and check the type
-
 #define FSC_MAX_DIR_NAME_LENGTH			(256)
 #define FSC_MAX_DEVICE_PATH_LENGTH		((std::max)(260,FSA_PATH_SIZE_MAX))	// max length for FSC device paths (should be at least equal or greater than supported by host filesystem)
 

src/Cafe/Filesystem/fscDeviceHostFS.cpp

@@ -157,19 +157,6 @@ bool FSCVirtualFile_Host::fscDirNext(FSCDirEntry* dirEntry)
 	return true;
 }
 
-void FSCVirtualFile_Host::Save(MemStreamWriter& writer)
-{
-	writer.writeBE<uint32>((uint32)Child::HOST);
-
-	writer.writeBE(m_path->string());
-	writer.writeBE((uint32)m_accessFlags);
-
-	writer.writeBE(m_seek);
-
-	FSCVirtualFile::Save(writer);
-}
-
-
 FSCVirtualFile* FSCVirtualFile_Host::OpenFile(const fs::path& path, FSC_ACCESS_FLAG accessFlags, sint32& fscStatus)
 {
 	if (!HAS_FLAG(accessFlags, FSC_ACCESS_FLAG::OPEN_FILE) && !HAS_FLAG(accessFlags, FSC_ACCESS_FLAG::OPEN_DIR))
@@ -308,4 +295,13 @@ public:
 bool FSCDeviceHostFS_Mount(std::string_view mountPath, std::string_view hostTargetPath, sint32 priority)
 {
 	return fsc_mount(mountPath, hostTargetPath, &fscDeviceHostFSC::instance(), nullptr, priority) == FSC_STATUS_OK;
-}
+}
+
+void FSCVirtualFile_Host::Save(MemStreamWriter& writer)
+{
+	writer.writeBE<uint32>((uint32)Child::HOST);
+	writer.writeBE(m_path->string());
+	writer.writeBE((uint32)m_accessFlags);
+	writer.writeBE(m_seek);
+	FSCVirtualFile::Save(writer);
+}

src/Cafe/Filesystem/fscDeviceHostFS.h

@@ -3,7 +3,6 @@
 class FSCVirtualFile_Host : public FSCVirtualFile
 {
 public:
-	void Save(MemStreamWriter& writer) override;
 	static FSCVirtualFile* OpenFile(const fs::path& path, FSC_ACCESS_FLAG accessFlags, sint32& fscStatus);
 	~FSCVirtualFile_Host() override;
 
@@ -19,6 +18,8 @@ public:
 	void fscSetFileLength(uint64 endOffset) override;
 	bool fscDirNext(FSCDirEntry* dirEntry) override;
 
+	void Save(MemStreamWriter& writer) override;
+
 private:
 	FSCVirtualFile_Host(uint32 type) : m_type(type) {};
 

src/Cafe/Filesystem/fscDeviceWua.cpp

@@ -15,11 +15,6 @@ protected:
 	};
 
 public:
-	void Save(MemStreamWriter& writer) override
-	{
-		throw std::exception("Not implemented");
-	}
-
 	sint32 fscGetType() override
 	{
 		return m_fscType;
@@ -112,6 +107,11 @@ public:
 		return true;
 	}
 
+	void Save(MemStreamWriter& writer) override
+	{
+		throw std::exception("Not implemented");
+	}
+
 private:
 	ZArchiveReader* m_archive{nullptr};
 	sint32 m_fscType;

src/Cafe/Filesystem/fscDeviceWud.cpp

@@ -22,11 +22,6 @@ protected:
 	}
 
 public:
-	void Save(MemStreamWriter& writer) override
-	{
-		throw std::exception("Not implemented");
-	}
-
 	sint32 fscGetType() override
 	{
 		return m_fscType;
@@ -113,6 +108,11 @@ public:
 		return true;
 	}
 
+	void Save(MemStreamWriter& writer) override
+	{
+		throw std::exception("Not implemented");
+	}
+
 private:
 	FSTVolume* m_volume{nullptr};
 	sint32 m_fscType;

src/Cafe/HW/MMU/MMU.cpp

@@ -80,37 +80,22 @@ MMURange* memory_getMMURangeByAddress(MPTR address)
 	return nullptr;
 }
 
-bool MMURange::serializeImpl(MemStreamWriter& streamWriter)
-{
-	streamWriter.writeBE<bool>(this->m_isMapped);
-	if (m_isMapped)
-	{
-		streamWriter.writeBE(this->baseAddress);
-		streamWriter.writeBE<uint8>((uint8)this->areaId);
-		streamWriter.writeBE<uint8>((uint8)this->flags);
-		streamWriter.writeBE(this->name);
-		streamWriter.writeBE(this->size);
-		streamWriter.writeBE(this->initSize);
-	}
-	return true;
-}
-
 template<>
-void MemStreamWriter::writeBE<MMURange>(const MMURange& v)
+void MemStreamWriter::writeBE(const MMURange& v)
 {
-	writeBE(v.m_isMapped);
+	writeBool(v.m_isMapped);
 	writeBE(v.baseAddress);
-	writeBE<uint8>((uint8)v.areaId);
+	writeBE((uint8)v.areaId);
-	writeBE<uint8>((uint8)v.flags);
+	writeBE((uint8)v.flags);
 	writeBE(v.name);
 	writeBE(v.size);
 	writeBE(v.initSize);
 }
 
 template <>
-void MemStreamReader::readBE<MMURange>(MMURange& mmuRange)
+void MemStreamReader::readBE(MMURange& mmuRange)
 {
-	bool needsMapped = readBE<bool>();
+	bool needsMapped = readBool();
 	mmuRange.m_isMapped = false;
 	mmuRange.baseAddress = readBE<uint32>();
 	mmuRange.areaId = (MMU_MEM_AREA_ID)readBE<uint8>();
@@ -122,23 +107,6 @@ void MemStreamReader::readBE<MMURange>(MMURange& mmuRange)
 		mmuRange.mapMem();
 }
 
-bool MMURange::deserializeImpl(MemStreamReader& streamReader)
-{
-	m_isMapped = streamReader.readBE<bool>();
-	if (m_isMapped)
-	{
-		baseAddress = streamReader.readBE<uint32>();
-		areaId = (MMU_MEM_AREA_ID)streamReader.readBE<uint8>();
-		this->flags = (MFLAG)streamReader.readBE<uint8>();
-		this->name = streamReader.readBE<std::string>();
-		this->size = streamReader.readBE<uint32>();
-		this->initSize = streamReader.readBE<uint32>();
-		m_isMapped = false;
-		mapMem();
-	}
-	return true;
-}
-
 MMURange::MMURange(const uint32 baseAddress, const uint32 size, MMU_MEM_AREA_ID areaId, const std::string_view name, MFLAG flags) : baseAddress(baseAddress), size(size), initSize(size), areaId(areaId), name(name), flags(flags)
 {
 	g_mmuRanges.emplace_back(this);

src/Cafe/HW/MMU/MMU.h

@@ -51,9 +51,6 @@ struct MMURange
 		FLAG_MAP_EARLY = (1 << 1), // map at Cemu launch, normally memory is mapped when a game is loaded
 	};
 
-	bool serializeImpl(MemStreamWriter& streamWriter);
-	bool deserializeImpl(MemStreamReader& streamReader);
-
 	MMURange(const uint32 baseAddress, const uint32 size, MMU_MEM_AREA_ID areaId, const std::string_view name, MFLAG flags = (MFLAG)0);
 
 	void mapMem();

src/Cafe/IOSU/fsa/iosu_fsa.cpp

@@ -36,7 +36,9 @@ namespace iosu
 			}
 		};
 
-		std::array<FSAClient, 624> sFSAClientArray;
+		static constexpr int const sFSAClientArraySize = 624;
+
+		std::array<FSAClient, sFSAClientArraySize> sFSAClientArray;
 
 		IOS_ERROR FSAAllocateClient(sint32& indexOut)
 		{
@@ -229,9 +231,10 @@ namespace iosu
 				return it.fscFile;
 			}
 
+			static constexpr int const m_handleTableSize = 0x3C0;
 		private:
 			uint32 m_currentCounter = 1;
-			std::array<_FSAHandleResource, 0x3C0> m_handleTable;
+			std::array<_FSAHandleResource, m_handleTableSize> m_handleTable;
 		};
 
 		_FSAHandleTable sFileHandleTable;
@@ -908,113 +911,76 @@ namespace iosu
 } // namespace iosu
 
 template <>
-void MemStreamWriter::writeBE<FSCDirEntry>(const FSCDirEntry& v);
+void MemStreamWriter::writeBE(const iosu::fsa::FSAClient& v)
-template <>
+{
-FSCDirEntry MemStreamReader::readBE<FSCDirEntry>();
+	writeBE(v.workingDirectory);
-template <>
+	writeBool(v.isAllocated);
-FSCVirtualFile::FSCDirIteratorState MemStreamReader::readBE<FSCVirtualFile::FSCDirIteratorState>();
+}
-template <>
-void MemStreamWriter::writeBE<FSCVirtualFile::FSCDirIteratorState>(const FSCVirtualFile::FSCDirIteratorState& v);
 
 template <>
-void MemStreamWriter::writeBE<iosu::fsa::_FSAHandleTable>(const iosu::fsa::_FSAHandleTable& v)
+void MemStreamReader::readBE(iosu::fsa::FSAClient& v)
+{
+	readBE(v.workingDirectory);
+	readBool(v.isAllocated);
+}
+
+template <>
+void MemStreamWriter::writeBE(const iosu::fsa::_FSAHandleTable& v)
 {
 	writeBE(v.m_currentCounter);
-	for (int i = 0; i < 0x3C0; i++)
+	for (sint32 i = 0; i < v.m_handleTableSize; i++)
 	{
 		writeBE(v.m_handleTable[i].handleCheckValue);
-		writeBE(v.m_handleTable[i].isAllocated);
+		writeBool(v.m_handleTable[i].isAllocated);
-		writeBE(v.m_handleTable[i].fscFile != nullptr);
+
+		writeBool(v.m_handleTable[i].fscFile != nullptr);
 		if (v.m_handleTable[i].fscFile != nullptr) v.m_handleTable[i].fscFile->Save(*this);
 	}
 }
 
 template <>
-iosu::fsa::_FSAHandleTable MemStreamReader::readBE<iosu::fsa::_FSAHandleTable>()
+void MemStreamReader::readBE(iosu::fsa::_FSAHandleTable& v)
 {
-	iosu::fsa::_FSAHandleTable table{};
+	readBE(v.m_currentCounter);
-	table.m_currentCounter = readBE<uint32>();
+	for (sint32 i = 0; i < v.m_handleTableSize; i++)
-	for (int i = 0; i < 0x3C0; i++)
 	{
-		table.m_handleTable[i].handleCheckValue = readBE<uint16>();
+		readBE(v.m_handleTable[i].handleCheckValue);
-		table.m_handleTable[i].isAllocated = readBE<bool>();
+		readBool(v.m_handleTable[i].isAllocated);
-		if (readBE<bool>()) table.m_handleTable[i].fscFile = FSCVirtualFile::Restore(*this);
-	}
-	return table;
-}
 
-template <>
+		if (readBool()) v.m_handleTable[i].fscFile = FSCVirtualFile::Restore(*this);
-void MemStreamWriter::writeBE<FSCVirtualFile::FSCDirIteratorState>(const FSCVirtualFile::FSCDirIteratorState& v)
-{
-	writeBE(v.index);
-	writeBE(v.dirEntries.size());
-	for (int i = 0; i < v.dirEntries.size(); i++)
-	{
-		writeBE(v.dirEntries[i]);
 	}
 }
 
-template <>
+namespace iosu
-void MemStreamWriter::writeBE<FSCDirEntry>(const FSCDirEntry& v)
 {
-	writeData(v.path, FSC_MAX_DIR_NAME_LENGTH);
+	namespace fsa
-	writeBE(v.isDirectory);
-	writeBE(v.isFile);
-	writeBE(v.fileSize);
-}
-
-template <>
-FSCDirEntry MemStreamReader::readBE<FSCDirEntry>()
-{
-	FSCDirEntry entry{};
-	readData(entry.path, FSC_MAX_DIR_NAME_LENGTH);
-	entry.isDirectory = readBE<bool>();
-	entry.isFile = readBE<bool>();
-	entry.fileSize = readBE<uint32>();
-	return entry;
-}
-
-template <>
-FSCVirtualFile::FSCDirIteratorState MemStreamReader::readBE<FSCVirtualFile::FSCDirIteratorState>()
-{
-	FSCVirtualFile::FSCDirIteratorState state{};
-	state.index = readBE<sint32>();
-	size_t size = readBE<size_t>();
-	for (size_t i = 0; i < size; i++)
 	{
-		state.dirEntries[i] = readBE<FSCDirEntry>();
+		void Save(MemStreamWriter& s)
-	}
-	return state;
-}
-
-namespace iosu::fsa
-{
-
-	void Save(MemStreamWriter& writer)
-	{
-		writer.writeData("iosu_fsa_S", 15);
-
-		writer.writeBE(sFSAIoMsgQueue);
-		for (size_t i = 0; i < 352; i++)
 		{
-			writer.writeBE(_m_sFSAIoMsgQueueMsgBuffer[i]);
+			s.writeSection("iosu_fsa");
+			s.writeBE(sFSAIoMsgQueue);
+			s.writeMPTR(_m_sFSAIoMsgQueueMsgBuffer);
+
+			for (sint32 i = 0; i < sFSAClientArraySize; i++)
+			{
+				s.writeBE(sFSAClientArray[i]);
+			}
+			s.writeBE(sDirHandleTable);
+			s.writeBE(sFileHandleTable);
 		}
-		writer.writeBE(sDirHandleTable);
-		writer.writeBE(sFileHandleTable);
-	}
 
-	void Restore(MemStreamReader& reader)
+		void Restore(MemStreamReader& s)
-	{
-		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++)
 		{
-			_m_sFSAIoMsgQueueMsgBuffer[i] = reader.readBE<iosu::kernel::IOSMessage>();
+			s.readSection("iosu_fsa");
+			s.readBE(sFSAIoMsgQueue);
+			s.readMPTR(_m_sFSAIoMsgQueueMsgBuffer);
+
+			for (sint32 i = 0; i < sFSAClientArraySize; i++)
+			{
+				s.readBE(sFSAClientArray[i]);
+			}
+			s.readBE(sDirHandleTable);
+			s.readBE(sFileHandleTable);
 		}
-		sDirHandleTable = reader.readBE<_FSAHandleTable>();
+	} // namespace fsa
-		sFileHandleTable = reader.readBE<_FSAHandleTable>();
+} // namespace iosu
-	}
-}

src/Cafe/OS/common/OSCommon.cpp

@@ -185,6 +185,47 @@ void osLib_returnFromFunction64(PPCInterpreter_t* hCPU, uint64 returnValue64)
 	hCPU->instructionPointer = hCPU->spr.LR;
 }
 
+void osLib_save(MemStreamWriter& s)
+{
+	coreinit_save(s);
+	dmae_save(s);
+	padscore::save(s);
+	nnAct_save(s);
+	nn::acp::save(s);
+	nnBoss_save(s);
+	nn::nfp::save(s);
+	nnUds_save(s);
+	nn::ndm::save(s);
+	nn::save::save(s);
+	nsysnet_save(s);
+	nn::fp::save(s);
+	nn::olv::save(s);
+	nlibcurl::save(s);
+	nsyshid::save(s);
+	camera::save(s);
+	procui_save(s);
+}
+void osLib_restore(MemStreamReader& s)
+{
+	coreinit_restore(s);
+	dmae_restore(s);
+	padscore::restore(s);
+	nnAct_restore(s);
+	nn::acp::restore(s);
+	nnBoss_restore(s);
+	nn::nfp::restore(s);
+	nnUds_restore(s);
+	nn::ndm::restore(s);
+	nn::save::restore(s);
+	nsysnet_restore(s);
+	nn::fp::restore(s);
+	nn::olv::restore(s);
+	nlibcurl::restore(s);
+	nsyshid::restore(s);
+	camera::restore(s);
+	procui_restore(s);
+}
+
 void osLib_load()
 {
 	// load HLE modules

src/Cafe/OS/common/OSCommon.h

@@ -6,6 +6,9 @@ struct PPCInterpreter_t;
 #define OSLIB_FUNCTIONTABLE_TYPE_FUNCTION	(1)
 #define OSLIB_FUNCTIONTABLE_TYPE_POINTER	(2)
 
+void osLib_save(MemStreamWriter& s);
+void osLib_restore(MemStreamReader& s);
+
 void osLib_load();
 void osLib_generateHashFromName(const char* name, uint32* hashA, uint32* hashB);
 sint32 osLib_getFunctionIndex(const char* libraryName, const char* functionName);

src/Cafe/OS/libs/camera/camera.cpp

@@ -242,6 +242,29 @@ namespace camera
 		g_cameraCounter = 0;
 	}
 
+	void save(MemStreamWriter& s)
+	{
+		s.writeSection("camera");
+
+		s.writePODVector(g_table_cameraHandles);
+		s.writePODVector(g_activeCameraInstances);
+		s.writeAtomic(g_cameraCounter);
+		s.writeMPTR(g_alarm_camera);
+		s.writeMPTR(g_cameraHandlerParam);
+	}
+	void restore(MemStreamReader& s)
+	{
+		s.readSection("camera");
+
+		std::unique_lock<std::recursive_mutex> _lock(g_mutex_camera);
+
+		s.readPODVector(g_table_cameraHandles);
+		s.readPODVector(g_activeCameraInstances);
+		s.readAtomic(g_cameraCounter);
+		s.readMPTR(g_alarm_camera);
+		s.readMPTR(g_cameraHandlerParam);
+	}
+
 	void load()
 	{
 		reset();
@@ -253,5 +276,4 @@ namespace camera
 		cafeExportRegister("camera", CAMClose, LogType::Placeholder);
 		cafeExportRegister("camera", CAMSubmitTargetSurface, LogType::Placeholder);
 	}
-}
+}
-

src/Cafe/OS/libs/camera/camera.h

@@ -6,5 +6,8 @@ namespace camera
 	sint32 CAMOpen(sint32 camHandle);
 	sint32 CAMClose(sint32 camHandle);
 
+	void save(MemStreamWriter& s);
+	void restore(MemStreamReader& s);
+
 	void load();
 };

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

@@ -316,54 +316,64 @@ namespace coreinit
 	}
 };
 
-void ci_Save(MemStreamWriter& s)
+void coreinit_save(MemStreamWriter& s)
 {
-	s.writeData("ci_S", 15);
+	s.writeSection("coreinit");
 
 	s.writeData(gCoreinitData, sizeof(coreinitData_t));
 	s.writeBE(placeholderFont);
 	s.writeBE(placeholderFontSize);
 
-	using namespace coreinit;
+	coreinit_Init_Save(s);
-	ci_CodeGen_Save(s);
+	coreinit::SysHeap_Save(s);
-	ci_DynLoad_Save(s);
+	coreinit::Thread_Save(s);
-	ci_FG_Save(s);
+	coreinit::MEM_Save(s);
-	ci_GHS_Save(s);
+	coreinit::FG_Save(s);
-	ci_IPC_Save(s);
+	coreinit::OverlayArena_Save(s);
-	ci_LockedCache_Save(s);
+	coreinit::DynLoad_Save(s);
-	ci_MEM_Save(s);
+	coreinit::GHS_Save(s);
-	ci_MemoryMapping_Save(s);
+	coreinit::LockedCache_Save(s);
-	ci_MessageQueue_Save(s);
+	coreinit::Alarm_Save(s);
-	ci_OverlayArena_Save(s);
+	coreinit::FS_Save(s);
-	ci_Sync_Save(s);
+	coreinit::SystemInfo_Save(s);
-	ci_SysHeap_Save(s);
+	coreinit::Synchronization_Save(s);
-	ci_SystemInfo_Save(s);
+	coreinit::MessageQueue_Save(s);
+	coreinit::IPC_Save(s);
+	coreinit::MemoryMapping_Save(s);
+	coreinit::CodeGen_Save(s);
+	coreinit_Callbacks_Save(s);
 }
 
-void ci_Restore(MemStreamReader& s)
+void coreinit_restore(MemStreamReader& s)
 {
-	char section[16] = { '\0' };
+	s.readSection("coreinit");
-	s.readData(section, 15);
+
-	cemu_assert_debug(strcmp(section, "ci_S") == 0);
+	bool recreate = false;
+	if (recreate)
+		coreinit::__OSDeleteAllActivePPCThreads();
 
 	s.readData(gCoreinitData, sizeof(coreinitData_t));
-	placeholderFont = s.readBE<MPTR>();
+	s.readBE(placeholderFont);
-	placeholderFontSize = s.readBE<sint32>();
+	s.readBE(placeholderFontSize);
 
-	using namespace coreinit;
+	coreinit_Init_Restore(s);
-	ci_CodeGen_Restore(s);
+	coreinit::SysHeap_Restore(s);
-	ci_DynLoad_Restore(s);
+	coreinit::Thread_Restore(s, recreate);
-	ci_FG_Restore(s);
+	coreinit::MEM_Restore(s);
-	ci_GHS_Restore(s);
+	coreinit::FG_Restore(s);
-	ci_IPC_Restore(s);
+	coreinit::OverlayArena_Restore(s);
-	ci_LockedCache_Restore(s);
+	coreinit::DynLoad_Restore(s);
-	ci_MEM_Restore(s);
+	coreinit::GHS_Restore(s);
-	ci_MemoryMapping_Restore(s);
+	coreinit::LockedCache_Restore(s);
-	ci_MessageQueue_Restore(s);
+	coreinit::Alarm_Restore(s);
-	ci_OverlayArena_Restore(s);
+	coreinit::FS_Restore(s);
-	ci_Sync_Restore(s);
+	coreinit::SystemInfo_Restore(s);
-	ci_SysHeap_Restore(s);
+	coreinit::Synchronization_Restore(s);
-	ci_SystemInfo_Restore(s);
+	coreinit::MessageQueue_Restore(s);
+	coreinit::IPC_Restore(s);
+	coreinit::MemoryMapping_Restore(s);
+	coreinit::CodeGen_Restore(s);
+	coreinit_Callbacks_Restore(s);
 }
 
 void coreinit_load()

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

@@ -11,15 +11,15 @@ 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 coreinit_Callbacks_Save(MemStreamWriter& s);
-void ci_Callbacks_Restore(MemStreamReader& s);
+void coreinit_Callbacks_Restore(MemStreamReader& s);
 
 // misc
 
-void coreinit_load();
+void coreinit_save(MemStreamWriter& s);
+void coreinit_restore(MemStreamReader& s);
 
-void ci_Save(MemStreamWriter& s);
+void coreinit_load();
-void ci_Restore(MemStreamReader& s);
 
 // coreinit shared memory
 
@@ -41,8 +41,8 @@ extern coreinitData_t* gCoreinitData;
 // coreinit init
 void coreinit_start(PPCInterpreter_t* hCPU);
 
-void ci_Init_Save(MemStreamWriter& s);
+void coreinit_Init_Save(MemStreamWriter& s);
-void ci_Init_Restore(MemStreamReader& s);
+void coreinit_Init_Restore(MemStreamReader& s);
 
 MPTR OSAllocFromSystem(uint32 size, uint32 alignment);
 void OSFreeToSystem(MPTR mem);

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

@@ -305,18 +305,18 @@ namespace coreinit
         __OSUnlockScheduler();
 	}
 
-	void ci_Alarm_Save(MemStreamWriter& s)
+	void Alarm_Save(MemStreamWriter& s)
 	{
-		s.writeData("ci_A_S", 15);
+		s.writeSection("coreinit_Alarm");
 
-		s.writeBE(g_alarmEvent.GetMPTR());
+		s.writeMPTR(g_alarmEvent);
-		s.writeBE(g_alarmThread.GetMPTR());
+		s.writeMPTR(g_alarmThread);
-		s.writeBE(_g_alarmThreadStack.GetMPTR());
+		s.writeMPTR(_g_alarmThreadStack);
-		s.writeBE(_g_alarmThreadName.GetMPTR());
+		s.writeMPTR(_g_alarmThreadName);
 
 		s.writeBE(coreinit_getOSTime());
 
-		s.writeBE(g_activeAlarms.size());
+		s.writeBE((uint64)g_activeAlarms.size());
 		for (auto& itr : g_activeAlarms)
 		{
 			s.writeBE(memory_getVirtualOffsetFromPointer(itr.first));
@@ -324,23 +324,21 @@ namespace coreinit
 		}
 	}
 
-	void ci_Alarm_Restore(MemStreamReader& s)
+	void Alarm_Restore(MemStreamReader& s)
 	{
 		OSAlarm_Shutdown();
 
-		char section[16] = { '\0' };
+		s.readSection("coreinit_Alarm");
-		s.readData(section, 15);
-		cemu_assert_debug(strcmp(section, "ci_A_S") == 0);
 
-		g_alarmEvent = (OSEvent*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+		s.readMPTR(g_alarmEvent);
-		g_alarmThread = (OSThread_t*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+		s.readMPTR(g_alarmThread);
-		_g_alarmThreadStack = (uint8*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+		s.readMPTR(_g_alarmThreadStack);
-		_g_alarmThreadName = (char*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+		s.readMPTR(_g_alarmThreadName);
 
 		uint64 currentTime = coreinit_getOSTime();
 		uint64_t timeOffset = currentTime - s.readBE<uint64_t>();
 
-		size_t alms = s.readBE<size_t>();
+		size_t alms = s.readBE<uint64>();
 		for (size_t alm = 0; alm < alms; alm++)
 		{
 			OSAlarm_t* alarm = (OSAlarm_t*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());

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

@@ -47,8 +47,8 @@ namespace coreinit
 
 	void OSAlarm_Shutdown();
 
-	void ci_Alarm_Save(MemStreamWriter& s);
+	void Alarm_Save(MemStreamWriter& s);
-	void ci_Alarm_Restore(MemStreamReader& s);
+	void Alarm_Restore(MemStreamReader& s);
 
 	void alarm_update();
 

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

@@ -31,14 +31,14 @@ struct CoreinitAsyncCallback
 		s_asyncCallbackSpinlock.unlock();
 	}
 
-	static std::vector<struct CoreinitAsyncCallback*>* getPoolPtr()
+	static std::vector<struct CoreinitAsyncCallback*>& getPool()
 	{
-		return &s_asyncCallbackPool;
+		return s_asyncCallbackPool;
 	}
 
-	static std::vector<struct CoreinitAsyncCallback*>* getQueuePtr()
+	static std::vector<struct CoreinitAsyncCallback*>& getQueue()
 	{
-		return &s_asyncCallbackQueue;
+		return s_asyncCallbackQueue;
 	}
 
 	friend void ci_Callbacks_Save(MemStreamWriter& s);
@@ -117,48 +117,26 @@ 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)
+void coreinit_Callbacks_Save(MemStreamWriter& s)
 {
-	s.writeData("ci_C_S", 15);
+	s.writeSection("coreinit_Callbacks");
-
+	s.writeMPTR(g_coreinitCallbackThread);
-	s.writeBE(g_coreinitCallbackThread.GetMPTR());
+	s.writeMPTR(_g_coreinitCallbackThreadStack);
-	s.writeBE(_g_coreinitCallbackThreadStack.GetMPTR());
+	s.writeMPTR(g_asyncCallbackAsync);
-	s.writeBE(g_asyncCallbackAsync.GetMPTR());
+	s.writeMPTR(_g_coreinitCBThreadName);
-	s.writeBE(_g_coreinitCBThreadName.GetMPTR());
+	s.writePODVector(CoreinitAsyncCallback::getPool());
-
+	s.writePODVector(CoreinitAsyncCallback::getQueue());
-	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)
+void coreinit_Callbacks_Restore(MemStreamReader& s)
 {
-	char section[16] = { '\0' };
+	s.readSection("coreinit_Callbacks");
-	s.readData(section, 15);
+	s.readMPTR(g_coreinitCallbackThread);
-	cemu_assert_debug(strcmp(section, "ci_C_S") == 0);
+	s.readMPTR(_g_coreinitCallbackThreadStack);
-
+	s.readMPTR(g_asyncCallbackAsync);
-	g_coreinitCallbackThread = (OSThread_t*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+	s.readMPTR(_g_coreinitCBThreadName);
-	_g_coreinitCallbackThreadStack = (uint8*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+	s.readPODVector(CoreinitAsyncCallback::getPool());
-	g_asyncCallbackAsync = (coreinit::OSSemaphore*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+	s.readPODVector(CoreinitAsyncCallback::getQueue());
-	_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()

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

@@ -136,18 +136,15 @@ namespace coreinit
 		return true;
 	}
 
-	void ci_CodeGen_Save(MemStreamWriter& s)
+	void CodeGen_Save(MemStreamWriter& s)
 	{
-		s.writeData("ci_CG_S", 15);
+		s.writeSection("coreinit_CodeGen");
 		s.writeData(&coreinitCodeGen, sizeof(coreinitCodeGen));
 	}
 
-	void ci_CodeGen_Restore(MemStreamReader& s)
+	void CodeGen_Restore(MemStreamReader& s)
 	{
-		char section[16] = { '\0' };
+		s.readSection("coreinit_CodeGen");
-		s.readData(section, 15);
-		cemu_assert_debug(strcmp(section, "ci_CG_S") == 0);
-
 		s.readData(&coreinitCodeGen, sizeof(coreinitCodeGen));
 	}
 

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

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

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

@@ -129,26 +129,22 @@ namespace coreinit
 		return 0;
 	}
 
-	void ci_DynLoad_Save(MemStreamWriter& s)
+	void DynLoad_Save(MemStreamWriter& s)
 	{
-		s.writeData("ci_DL_S", 15);
+		s.writeSection("coreinit_DynLoad");
-
 		s.writeBE(_osDynLoadFuncAlloc);
 		s.writeBE(_osDynLoadFuncFree);
 		s.writeBE(_osDynLoadTLSFuncAlloc);
 		s.writeBE(_osDynLoadTLSFuncFree);
 	}
 
-	void ci_DynLoad_Restore(MemStreamReader& s)
+	void DynLoad_Restore(MemStreamReader& s)
 	{
-		char section[16] = { '\0' };
+		s.readSection("coreinit_DynLoad");
-		s.readData(section, 15);
+		s.readBE(_osDynLoadFuncAlloc);
-		cemu_assert_debug(strcmp(section, "ci_DL_S") == 0);
+		s.readBE(_osDynLoadFuncFree);
-
+		s.readBE(_osDynLoadTLSFuncAlloc);
-		_osDynLoadFuncAlloc = s.readBE<MPTR>();
+		s.readBE(_osDynLoadTLSFuncFree);
-		_osDynLoadFuncFree = s.readBE<MPTR>();
-		_osDynLoadTLSFuncAlloc = s.readBE<MPTR>();
-		_osDynLoadTLSFuncFree = s.readBE<MPTR>();
 	}
 
 	void InitializeDynLoad()

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

@@ -14,8 +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 DynLoad_Save(MemStreamWriter& s);
-	void ci_DynLoad_Restore(MemStreamReader& s);
+	void DynLoad_Restore(MemStreamReader& s);
 
 	void InitializeDynLoad();
 }

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

@@ -191,23 +191,19 @@ namespace coreinit
 		osLib_returnFromFunction(hCPU, r ? 1 : 0);
 	}
 
-	void ci_FG_Save(MemStreamWriter& s)
+	void FG_Save(MemStreamWriter& s)
 	{
-		s.writeData("ci_FG_S", 15);
+		s.writeSection("coreinit_FG");
-
+		s.writeMPTR(fgAddr);
-		s.writeBE(fgAddr.GetMPTR());
+		s.writeMPTR(fgSaveAreaAddr);
-		s.writeBE(fgSaveAreaAddr.GetMPTR());
 		s.writeData(&fgAreaEntries, sizeof(fgAreaEntries) * FG_BUCKET_AREA_COUNT);
 	}
 
-	void ci_FG_Restore(MemStreamReader& s)
+	void FG_Restore(MemStreamReader& s)
 	{
-		char section[16] = { '\0' };
+		s.readSection("coreinit_FG");
-		s.readData(section, 15);
+		s.readMPTR(fgAddr);
-		cemu_assert_debug(strcmp(section, "ci_FG_S") == 0);
+		s.readMPTR(fgSaveAreaAddr);
-
-		fgAddr = memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
-		fgSaveAreaAddr = memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
 		s.readData(&fgAreaEntries, sizeof(fgAreaEntries) * FG_BUCKET_AREA_COUNT);
 	}
 

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

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

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

@@ -2638,38 +2638,30 @@ namespace coreinit
 		return FSA_RESULT::OK;
 	}
 
-	void ci_FS_Save(MemStreamWriter& s)
+	void FS_Save(MemStreamWriter& s)
 	{
-		s.writeData("ci_FS_S", 15);
+		s.writeSection("coreinit_FS");
 		s.writeData(g_fsRegisteredClientBodies, sizeof(FSClientBody_t));
-		s.writeBE(_sdCard01Mounted);
+		s.writeBool(_sdCard01Mounted);
-		s.writeBE(_mlc01Mounted);
+		s.writeBool(_mlc01Mounted);
-		s.writeBE(_tempFSSpace.GetMPTR());
+		s.writeMPTR(_tempFSSpace);
-		size_t s_fsa_activeClients_size = s_fsa_activeClients.size();
+		s.writePODVector(s_fsa_activeClients);
-		s.writeBE(s_fsa_activeClients_size);
+		s.writeMPTR(s_fsaIpcPool);
-		s.writeData(&s_fsa_activeClients, sizeof(FSAClientHandle) * s_fsa_activeClients_size);
+		s.writeMPTR(s_fsaIpcPoolBuffer);
-		s.writeBE(s_fsaIpcPool.GetMPTR());
+		s.writeMPTR(s_fsaIpcPoolBufferNumItems);
-		s.writeBE(s_fsaIpcPoolBuffer.GetMPTR());
-		s.writeBE(s_fsaIpcPoolBufferNumItems.GetMPTR());
 	}
 
-	void ci_FS_Restore(MemStreamReader& s)
+	void FS_Restore(MemStreamReader& s)
 	{
-		char section[16] = { '\0' };
+		s.readSection("coreinit_FS");
-		s.readData(section, 15);
-		cemu_assert_debug(strcmp(section, "ci_FS_S") == 0);
-
 		s.readData(g_fsRegisteredClientBodies, sizeof(FSClientBody_t));
-		_sdCard01Mounted = s.readBE<bool>();
+		s.readBool(_sdCard01Mounted);
-		_mlc01Mounted = s.readBE<bool>();
+		s.readBool(_mlc01Mounted);
-		_tempFSSpace = memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+		s.readMPTR(_tempFSSpace);
-		size_t s_fsa_activeClients_size = s.readBE<size_t>();
+		s.readPODVector(s_fsa_activeClients);
-		s_fsa_activeClients.clear();
+		s.readMPTR(s_fsaIpcPool);
-		s_fsa_activeClients.resize(s_fsa_activeClients_size);
+		s.readMPTR(s_fsaIpcPoolBuffer);
-		s.readData(&s_fsa_activeClients, sizeof(FSAClientHandle) * s_fsa_activeClients_size);
+		s.readMPTR(s_fsaIpcPoolBufferNumItems);
-		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 ci_FS_Save(MemStreamWriter& s);
+	void FS_Save(MemStreamWriter& s);
-	void ci_FS_Restore(MemStreamReader& s);
+	void FS_Restore(MemStreamReader& s);
 
 	void InitializeFS();
 }; // namespace coreinit

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

@@ -258,24 +258,22 @@ namespace coreinit
 		return memory_getPointerFromVirtualOffset(_swapEndianU32(tlsBlock->addr) + _swapEndianU32(tlsIndex->ukn04));
 	}
 
-	void ci_GHS_Save(MemStreamWriter& s)
+	void GHS_Save(MemStreamWriter& s)
 	{
-		s.writeData("ci_GHS_S", 15);
+		s.writeSection("coreinit_GHS");
-
+		s.writeMPTR(g_ghs_data);
-		s.writeBE(g_ghs_data.GetMPTR());
+		s.writeMPTR(_flockMutexArray);
-		s.writeBE(_flockMutexArray.GetMPTR());
+		s.writeData(reinterpret_cast<uint8*>(_flockMutexMask), sizeof(uint8) * GHS_FOPEN_MAX);
-		s.writeData(_flockMutexMask, sizeof(bool) * GHS_FOPEN_MAX);
 	}
 
-	void ci_GHS_Restore(MemStreamReader& s)
+	void GHS_Restore(MemStreamReader& s)
 	{
-		char section[16] = { '\0' };
+		s.readSection("coreinit_GHS");
-		s.readData(section, 15);
+		s.readMPTR(g_ghs_data);
-		cemu_assert_debug(strcmp(section, "ci_GHS_S") == 0);
+		s.readMPTR(_flockMutexArray);
-
+		uint8 _flockMutexMaskTmp[GHS_FOPEN_MAX] = { 0 };
-		g_ghs_data = (GHSAccessibleData*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+		s.readData(_flockMutexMaskTmp, sizeof(uint8) * GHS_FOPEN_MAX);
-		_flockMutexArray = (coreinit::OSMutex*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+		memcpy(_flockMutexMask, reinterpret_cast<bool*>(_flockMutexMaskTmp), sizeof(bool) * GHS_FOPEN_MAX);
-		s.readData(_flockMutexMask, sizeof(bool) * GHS_FOPEN_MAX);
 	}
 
 	void InitializeGHS()

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

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

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

@@ -462,32 +462,28 @@ namespace coreinit
 		return r;
 	}
 
-	void ci_IPC_Save(MemStreamWriter& s)
+	void IPC_Save(MemStreamWriter& s)
 	{
-		s.writeData("ci_IPC_S", 15);
+		s.writeSection("coreinit_IPC");
-
+		s.writeMPTR(s_ipcResourceBuffers);
-		s.writeBE(s_ipcResourceBuffers.GetMPTR());
+		s.writeMPTR(s_ipcDriver);
-		s.writeBE(s_ipcDriver.GetMPTR());
+		s.writeMPTR(gIPCThread);
-		s.writeBE(gIPCThread.GetMPTR());
+		s.writeMPTR(_gIPCThreadStack);
-		s.writeBE(_gIPCThreadStack.GetMPTR());
+		s.writeMPTR(_gIPCThreadNameStorage);
-		s.writeBE(_gIPCThreadNameStorage.GetMPTR());
+		s.writeMPTR(gIPCThreadMsgQueue);
-		s.writeBE(gIPCThreadMsgQueue.GetMPTR());
+		s.writeMPTR(_gIPCThreadSemaphoreStorage);
-		s.writeBE(_gIPCThreadSemaphoreStorage.GetMPTR());
 	}
 
-	void ci_IPC_Restore(MemStreamReader& s)
+	void IPC_Restore(MemStreamReader& s)
 	{
-		char section[16] = { '\0' };
+		s.readSection("coreinit_IPC");
-		s.readData(section, 15);
+		s.readMPTR(s_ipcResourceBuffers);
-		cemu_assert_debug(strcmp(section, "ci_IPC_S") == 0);
+		s.readMPTR(s_ipcDriver);
-
+		s.readMPTR(gIPCThread);
-		s_ipcResourceBuffers = (IPCResourceBuffer*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+		s.readMPTR(_gIPCThreadStack);
-		s_ipcDriver = (IPCDriver*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+		s.readMPTR(_gIPCThreadNameStorage);
-		gIPCThread = (OSThread_t*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+		s.readMPTR(gIPCThreadMsgQueue);
-		_gIPCThreadStack = memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+		s.readMPTR(_gIPCThreadSemaphoreStorage);
-		_gIPCThreadNameStorage = memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
-		gIPCThreadMsgQueue = (OSMessageQueue*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
-		_gIPCThreadSemaphoreStorage = (OSMessage*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
 	}
 
 	void InitializeIPC()

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

@@ -12,8 +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 IPC_Save(MemStreamWriter& s);
-	void ci_IPC_Restore(MemStreamReader& s);
+	void IPC_Restore(MemStreamReader& s);
 
 	void InitializeIPC();
 };

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

@@ -216,24 +216,20 @@ void coreinit_start(PPCInterpreter_t* hCPU)
 	hCPU->instructionPointer = _coreinitTitleEntryPoint;
 }
 
-void ci_Init_Save(MemStreamWriter& s)
+void coreinit_Init_Save(MemStreamWriter& s)
 {
-	s.writeData("ci_Init_S", 15);
+	s.writeSection("coreinit_Init");
-
 	s.writeData(_coreinitInfo, sizeof(coreinitInit_t));
 	s.writeBE(argStorageIndex);
-	s.writeBE(g_preinitUserParam.GetMPTR());
+	s.writeMPTR(g_preinitUserParam);
 	s.writeBE(_coreinitTitleEntryPoint);
 }
 
-void ci_Init_Restore(MemStreamReader& s)
+void coreinit_Init_Restore(MemStreamReader& s)
 {
-	char section[16] = { '\0' };
+	s.readSection("coreinit_Init");
-	s.readData(section, 15);
-	cemu_assert_debug(strcmp(section, "ci_Init_S") == 0);
-
 	s.readData(_coreinitInfo, sizeof(coreinitInit_t));
-	argStorageIndex = s.readBE<sint32>();
+	s.readBE(argStorageIndex);
-	g_preinitUserParam = (PreinitUserHeapStruct*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+	s.readMPTR(g_preinitUserParam);
-	_coreinitTitleEntryPoint = s.readBE<sint32>();
+	s.readBE(_coreinitTitleEntryPoint);
 }

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

@@ -271,24 +271,20 @@ namespace coreinit
 		osLib_returnFromFunction(hCPU, 0);
 	}
 
-	void ci_LockedCache_Save(MemStreamWriter& s)
+	void LockedCache_Save(MemStreamWriter& s)
 	{
-		s.writeData("ci_LC_S", 15);
+		s.writeSection("coreinit_LockedCache");
-
 		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)
+	void LockedCache_Restore(MemStreamReader& s)
 	{
-		char section[16] = { '\0' };
+		s.readSection("coreinit_LockedCache");
-		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>();
+		s.readBE(_lcDisableErrorCounter);
 	}
 
 	void InitializeLC()

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

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

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

@@ -630,44 +630,40 @@ namespace coreinit
         memset(&g_list3, 0, sizeof(g_list3));
     }
 
-	void ci_MEM_Save(MemStreamWriter& s)
+	void MEM_Save(MemStreamWriter& s)
 	{
-		s.writeData("ci_MEM_S", 15);
+		s.writeSection("coreinit_MEM");
-
 		s.writeBE(sysAreaAllocatorOffset);
 		s.writeBE(g_heapTableCount);
 		s.writeData(g_heapTable, sizeof(MEMHeapBase) * MEM_MAX_HEAP_TABLE);
-		s.writeBE(g_slockInitialized);
+		s.writeBool(g_slockInitialized);
-		s.writeBE(g_listsInitialized);
+		s.writeBool(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.writeMPTR(gHeapGlobalLock);
 		s.writeData(&gDefaultHeap, sizeof(MEMHeapBase));
 		s.writeData(&sHeapBaseHandle, sizeof(MEMHeapBase) * 9);
-		s.writeBE(gDefaultHeapAllocator.GetMPTR());
+		s.writeMPTR(gDefaultHeapAllocator);
 	}
 
-	void ci_MEM_Restore(MemStreamReader& s)
+	void MEM_Restore(MemStreamReader& s)
 	{
-		char section[16] = { '\0' };
+		s.readSection("coreinit_MEM");
-		s.readData(section, 15);
+		s.readBE(sysAreaAllocatorOffset);
-		cemu_assert_debug(strcmp(section, "ci_MEM_S") == 0);
+		s.readBE(g_heapTableCount);
-
-		sysAreaAllocatorOffset = s.readBE<MPTR>();
-		g_heapTableCount = s.readBE<sint32>();
 		s.readData(g_heapTable, sizeof(MEMHeapBase) * MEM_MAX_HEAP_TABLE);
-		g_slockInitialized = s.readBE<bool>();
+		s.readBool(g_slockInitialized);
-		g_listsInitialized = s.readBE<bool>();
+		s.readBool(g_listsInitialized);
 		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.readMPTR(gHeapGlobalLock);
 		s.readData(&gDefaultHeap, sizeof(MEMHeapBase));
 		s.readData(&sHeapBaseHandle, sizeof(MEMHeapBase) * 9);
-		gDefaultHeapAllocator = (MEMAllocatorFunc*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+		s.readMPTR(gDefaultHeapAllocator);
 	}
 
 	void InitializeMEM()

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

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

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

@@ -153,25 +153,16 @@ namespace coreinit
 		return 1;
 	}
 
-	void ci_MemoryMapping_Save(MemStreamWriter& s)
+	void MemoryMapping_Save(MemStreamWriter& s)
 	{
-		s.writeData("ci_MemMap_S", 15);
+		s.writeSection("coreinit_MemoryMapping ");
-		
+		s.writePODVector(s_allocatedVirtMemory);
-		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)
+	void MemoryMapping_Restore(MemStreamReader& s)
 	{
-		char section[16] = { '\0' };
+		s.readSection("coreinit_MemoryMapping ");
-		s.readData(section, 15);
+		s.readPODVector(s_allocatedVirtMemory);
-		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()

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

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

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

@@ -117,22 +117,18 @@ namespace coreinit
 		return g_systemMessageQueue.GetPtr();
 	}
 
-	void ci_MessageQueue_Save(MemStreamWriter& s)
+	void MessageQueue_Save(MemStreamWriter& s)
 	{
-		s.writeData("ci_MessQue_S", 15);
+		s.writeSection("coreinit_MessageQueue");
-
+		s.writeMPTR(g_systemMessageQueue);
-		s.writeBE(g_systemMessageQueue.GetMPTR());
+		s.writeMPTR(_systemMessageQueueArray);
-		s.writeBE(_systemMessageQueueArray.GetMPTR());
 	}
 
-	void ci_MessageQueue_Restore(MemStreamReader& s)
+	void MessageQueue_Restore(MemStreamReader& s)
 	{
-		char section[16] = { '\0' };
+		s.readSection("coreinit_MessageQueue");
-		s.readData(section, 15);
+		s.readMPTR(g_systemMessageQueue);
-		cemu_assert_debug(strcmp(section, "ci_MessQue_S") == 0);
+		s.readMPTR(_systemMessageQueueArray);
-
-		g_systemMessageQueue = (OSMessageQueue*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
-		_systemMessageQueueArray = (OSMessage*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
 	}
 
 	void InitializeMessageQueue()

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

@@ -36,8 +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 MessageQueue_Save(MemStreamWriter& s);
-	void ci_MessageQueue_Restore(MemStreamReader& s);
+	void MessageQueue_Restore(MemStreamReader& s);
 
 	void InitializeMessageQueue();
 };

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

@@ -25,19 +25,15 @@ namespace coreinit
 		*areaSize = MEMORY_OVERLAY_AREA_SIZE;
 	}
 
-	void ci_OverlayArena_Save(MemStreamWriter& s)
+	void OverlayArena_Save(MemStreamWriter& s)
 	{
-		s.writeData("ci_OverArea_S", 15);
+		s.writeSection("coreinit_OverlayArena");
-
+		s.writeBool(g_coreinitOverlayArena.isEnabled);
-		s.writeData(&g_coreinitOverlayArena, sizeof(g_coreinitOverlayArena));
 	}
-	void ci_OverlayArena_Restore(MemStreamReader& s)
+	void OverlayArena_Restore(MemStreamReader& s)
 	{
-		char section[16] = { '\0' };
+		s.readSection("coreinit_OverlayArena");
-		s.readData(section, 15);
+		s.readBool(g_coreinitOverlayArena.isEnabled);
-		cemu_assert_debug(strcmp(section, "ci_OverArea_S") == 0);
-
-		s.readData(&g_coreinitOverlayArena, sizeof(g_coreinitOverlayArena));
 	}
 
 	void InitializeOverlayArena()

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

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

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

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

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

@@ -32,24 +32,20 @@ namespace coreinit
 		_sysHeapFreeCounter = 0;
 	}
 
-	void ci_SysHeap_Save(MemStreamWriter& s)
+	void SysHeap_Save(MemStreamWriter& s)
 	{
-		s.writeData("ci_SysHeap_S", 15);
+		s.writeSection("coreinit_SysHeap");
-
 		s.writeData(_sysHeapHandle, sizeof(MEMHeapBase));
 		s.writeBE(_sysHeapAllocCounter);
 		s.writeBE(_sysHeapFreeCounter);
 	}
 
-	void ci_SysHeap_Restore(MemStreamReader& s)
+	void SysHeap_Restore(MemStreamReader& s)
 	{
-		char section[16] = { '\0' };
+		s.readSection("coreinit_SysHeap");
-		s.readData(section, 15);
-		cemu_assert_debug(strcmp(section, "ci_SysHeap_S") == 0);
-
 		s.readData(_sysHeapHandle, sizeof(MEMHeapBase));
-		_sysHeapAllocCounter = s.readBE<sint32>();
+		s.readBE(_sysHeapAllocCounter);
-		_sysHeapFreeCounter = s.readBE<sint32>();
+		s.readBE(_sysHeapFreeCounter);
 	}
 
 	void InitializeSysHeap()

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

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

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

@@ -10,20 +10,16 @@ namespace coreinit
 		return *g_system_info.GetPtr();
 	}
 
-	void ci_SystemInfo_Save(MemStreamWriter& s)
+	void SystemInfo_Save(MemStreamWriter& s)
 	{
-		s.writeData("ci_SysInfo_S", 15);
+		s.writeSection("coreinit_SysInfo");
-
+		s.writeMPTR(g_system_info);
-		s.writeBE(g_system_info.GetMPTR());
 	}
 
-	void ci_SystemInfo_Restore(MemStreamReader& s)
+	void SystemInfo_Restore(MemStreamReader& s)
 	{
-		char section[16] = { '\0' };
+		s.readSection("coreinit_SysInfo");
-		s.readData(section, 15);
+		s.readMPTR(g_system_info);
-		cemu_assert_debug(strcmp(section, "ci_SysInfo_S") == 0);
-
-		g_system_info = (OSSystemInfo*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
 	}
 
 	void InitializeSystemInfo()

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

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

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

@@ -1331,12 +1331,13 @@ namespace coreinit
 		}
 	}
 
-	void ci_Thread_Save(MemStreamWriter& s)
+	void Thread_Save(MemStreamWriter& s)
 	{
-		s.writeData("ci_T_S", 15);
+		s.writeSection("coreinit_Thread");
 
-		s.writeBE(g_activeThreadQueue.GetMPTR());
+		s.writeBE((uint8)sSchedulerActive.load());
-		s.writeBE(g_coreRunQueue.GetMPTR());
+		s.writeMPTR(g_activeThreadQueue);
+		s.writeMPTR(g_coreRunQueue);
 
 		s.writeBE(activeThreadCount);
 		for (sint32 i = 0; i < activeThreadCount; i++)
@@ -1345,25 +1346,25 @@ namespace coreinit
 		}
 		for (sint32 i = 0; i < PPC_CORE_COUNT; i++)
 		{
-			s.writeBE(memory_getVirtualOffsetFromPointer(__currentCoreThread[i]));
+			s.writePTR(__currentCoreThread[i]);
 			s.writeBE(s_lehmer_lcg[i]);
-			s.writeBE(s_terminatorThreads[i].terminatorThread.GetMPTR());
+			s.writeMPTR(s_terminatorThreads[i].terminatorThread);
-			s.writeBE(s_terminatorThreads[i].threadStack.GetMPTR());
+			s.writeMPTR(s_terminatorThreads[i].threadStack);
-			s.writeBE(s_terminatorThreads[i].threadName.GetMPTR());
+			s.writeMPTR(s_terminatorThreads[i].threadName);
-			s.writeBE(s_terminatorThreads[i].semaphoreQueuedDeallocators.GetMPTR());
+			s.writeMPTR(s_terminatorThreads[i].semaphoreQueuedDeallocators);
+			s.writeMPTR(_defaultThreadName[i]);
 		}
-		s.writeBE(s_defaultThreads.GetMPTR());
+		s.writeMPTR(s_defaultThreads);
-		s.writeBE(s_stack.GetMPTR());
+		s.writeMPTR(s_stack);
 	}
 
-	void ci_Thread_Restore(MemStreamReader& s, bool recreate)
+	void Thread_Restore(MemStreamReader& s, bool recreate)
 	{
-		char section[16] = { '\0' };
+		s.readSection("coreinit_Thread");
-		s.readData(section,15);
-		cemu_assert_debug(strcmp(section, "ci_T_S") == 0);
 
-		g_activeThreadQueue = (OSThreadQueue*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+		sSchedulerActive.store(s.readBE<uint8>());
-		g_coreRunQueue = (OSThreadQueue*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+		s.readMPTR(g_activeThreadQueue);
+		s.readMPTR(g_coreRunQueue);
 
 		sint32 prevActiveThreadCount = s.readBE<sint32>();
 		for (sint32 i = 0; i < prevActiveThreadCount; i++)
@@ -1383,15 +1384,16 @@ namespace coreinit
 		}
 		for (sint32 i = 0; i < PPC_CORE_COUNT; i++)
 		{
-			__currentCoreThread[i] = (OSThread_t*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+			s.readPTR(__currentCoreThread[i]);
-			s_lehmer_lcg[i] = s.readBE<uint32>();
+			s.readBE(s_lehmer_lcg[i]);
-			s_terminatorThreads[i].terminatorThread = (OSThread_t*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+			s.readMPTR(s_terminatorThreads[i].terminatorThread);
-			s_terminatorThreads[i].threadStack = (uint8*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+			s.readMPTR(s_terminatorThreads[i].threadStack);
-			s_terminatorThreads[i].threadName = (char*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+			s.readMPTR(s_terminatorThreads[i].threadName);
-			s_terminatorThreads[i].semaphoreQueuedDeallocators = (OSSemaphore*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+			s.readMPTR(s_terminatorThreads[i].semaphoreQueuedDeallocators);
+			s.readMPTR(_defaultThreadName[i]);
 		}
-		s_defaultThreads = (OSThread_t*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+		s.readMPTR(s_defaultThreads);
-		s_stack = (uint8*)memory_getPointerFromVirtualOffset(s.readBE<MPTR>());
+		s.readMPTR(s_stack);
 	}
 
 	void SuspendActiveThreads()

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

@@ -496,15 +496,15 @@ static_assert(sizeof(OSThread_t) == 0x6A0-4); // todo - determine correct size
 
 namespace coreinit
 {
-	void ci_Thread_Save(MemStreamWriter& s);
+	void Thread_Save(MemStreamWriter& s);
-	void ci_Thread_Restore(MemStreamReader& s, bool recreate);
+	void Thread_Restore(MemStreamReader& s, bool recreate);
 	void SuspendActiveThreads();
 	void ResumeActiveThreads();
 
 	void InitializeThread();
 
-	void ci_Sync_Save(MemStreamWriter& s);
+	void Synchronization_Save(MemStreamWriter& s);
-	void ci_Sync_Restore(MemStreamReader& s);
+	void Synchronization_Restore(MemStreamReader& s);
 
 	void InitializeConcurrency();
 

src/Cafe/OS/libs/dmae/dmae.cpp

@@ -108,6 +108,17 @@ void dmaeExport_DMAEGetRetiredTimeStamp(PPCInterpreter_t* hCPU)
 	osLib_returnFromFunction64(hCPU, dmaeRetiredTimestamp);
 }
 
+void dmae_save(MemStreamWriter& s)
+{
+	s.writeSection("dmae");
+	s.writeBE(dmaeRetiredTimestamp);
+}
+
+void dmae_restore(MemStreamReader& s)
+{
+	s.readSection("dmae");
+	s.readBE(dmaeRetiredTimestamp);
+}
 
 void dmae_load()
 {

src/Cafe/OS/libs/dmae/dmae.h

@@ -1 +1,4 @@
+void dmae_save(MemStreamWriter& s);
+void dmae_restore(MemStreamReader& s);
+
 void dmae_load();

src/Cafe/OS/libs/nlibcurl/nlibcurl.cpp

@@ -1354,6 +1354,29 @@ void export_curl_global_init_mem(PPCInterpreter_t* hCPU)
 	osLib_returnFromFunction(hCPU, result);
 }
 
+void save(MemStreamWriter& s)
+{
+	s.writeSection("nlibcurl");
+	s.writeBE(g_nlibcurl.initialized);
+	s.writeMPTR(g_nlibcurl.proxyConfig);
+	s.writeMPTR(g_nlibcurl.malloc);
+	s.writeMPTR(g_nlibcurl.free);
+	s.writeMPTR(g_nlibcurl.realloc);
+	s.writeMPTR(g_nlibcurl.strdup);
+	s.writeMPTR(g_nlibcurl.calloc);
+}
+void restore(MemStreamReader& s)
+{
+	s.readSection("nlibcurl");
+	s.readBE(g_nlibcurl.initialized);
+	s.readMPTR(g_nlibcurl.proxyConfig);
+	s.readMPTR(g_nlibcurl.malloc);
+	s.readMPTR(g_nlibcurl.free);
+	s.readMPTR(g_nlibcurl.realloc);
+	s.readMPTR(g_nlibcurl.strdup);
+	s.readMPTR(g_nlibcurl.calloc);
+}
+
 void load()
 {
 	osLib_addFunction("nlibcurl", "curl_global_init_mem", export_curl_global_init_mem);

src/Cafe/OS/libs/nlibcurl/nlibcurl.h

@@ -2,5 +2,8 @@
 
 namespace nlibcurl
 {
+	void save(MemStreamWriter& s);
+	void restore(MemStreamReader& s);
+
 	void load();
 }

src/Cafe/OS/libs/nn_acp/nn_acp.cpp

@@ -490,6 +490,18 @@ namespace acp
 		osLib_returnFromFunction(hCPU, 0);
 	}
 
+	void save(MemStreamWriter& s)
+	{
+		s.writeSection("nn_acp");
+		s.writeBool(sSaveDirMounted);
+	}
+
+	void restore(MemStreamReader& s)
+	{
+		s.readSection("nn_acp");
+		s.readBool(sSaveDirMounted);
+	}
+
 	void load()
 	{
 		cafeExportRegister("nn_acp", ACPCheckApplicationDeviceEmulation, LogType::Placeholder);

src/Cafe/OS/libs/nn_acp/nn_acp.h

@@ -24,6 +24,9 @@ namespace acp
 	ACPStatus ACPCreateSaveDir(uint32 persistentId, ACPDeviceType type);
 	ACPStatus ACPUpdateSaveTimeStamp(uint32 persistentId, uint64 titleId, ACPDeviceType deviceType);;
 
+	void save(MemStreamWriter& s);
+	void restore(MemStreamReader& s);
+
 	void load();
 }
 }

src/Cafe/OS/libs/nn_act/nn_act.cpp

@@ -664,6 +664,19 @@ void nnActExport_AcquirePrincipalIdByAccountId(PPCInterpreter_t* hCPU)
 	osLib_returnFromFunction(hCPU, result);
 }
 
+void nnAct_save(MemStreamWriter& s)
+{
+	s.writeSection("nn_act");
+	s.writeBE(nn::act::g_initializeCount);
+	s.writeBE((uint32)g_isParentalControlCheckEnabled);
+}
+void nnAct_restore(MemStreamReader& s)
+{
+	s.readSection("nn_act");
+	s.readBE(nn::act::g_initializeCount);
+	g_isParentalControlCheckEnabled = s.readBE<uint32>();
+}
+
 // register account functions
 void nnAct_load()
 {

src/Cafe/OS/libs/nn_act/nn_act.h

@@ -33,4 +33,7 @@ namespace act
 }
 }
 
+void nnAct_save(MemStreamWriter& s);
+void nnAct_restore(MemStreamReader& s);
+
 void nnAct_load();

src/Cafe/OS/libs/nn_aoc/nn_aoc.cpp

@@ -36,6 +36,7 @@ namespace nn
 
 		struct AOCCacheEntry
 		{
+			AOCCacheEntry() {};
 			AOCCacheEntry(uint64 titleId) : aocTitleId(titleId) {};
 
 			uint64 aocTitleId;
@@ -149,6 +150,20 @@ namespace nn
 			return AOC_RESULT::ERROR_OK;
 		}
 
+		void save(MemStreamWriter& s)
+		{
+			s.writeSection("nn_aoc");
+			s.writePODVector(sAocCache);
+			s.writeBool(sAocCacheGenerated);
+		}
+
+		void restore(MemStreamReader& s)
+		{
+			s.readSection("nn_aoc");
+			s.readPODVector(sAocCache);
+			s.readBool(sAocCacheGenerated);
+		}
+
 		void Initialize()
 		{
 			cafeExportRegister("nn_aoc", AOC_CalculateWorkBufferSize, LogType::NN_AOC);

src/Cafe/OS/libs/nn_aoc/nn_aoc.h

@@ -2,6 +2,9 @@ namespace nn
 {
 	namespace aoc
 	{
+		void save(MemStreamWriter& s);
+		void restore(MemStreamReader& s);
+
 		void Initialize();
 	}
 }

src/Cafe/OS/libs/nn_boss/nn_boss.cpp

@@ -1714,6 +1714,22 @@ void nnBossNsDataExport_seek(PPCInterpreter_t* hCPU)
 	osLib_returnFromFunction(hCPU, r);
 }
 
+void nnBoss_save(MemStreamWriter& s)
+{
+	s.writeSection("nn_boss");
+	s.writeMPTR(nn::boss::g_mutex);
+	s.writeBE(nn::boss::g_initCounter);
+	s.writeBool(nn::boss::g_isInitialized);
+}
+
+void nnBoss_restore(MemStreamReader& s)
+{
+	s.readSection("nn_boss");
+	s.readMPTR(nn::boss::g_mutex);
+	s.readBE(nn::boss::g_initCounter);
+	s.readBool(nn::boss::g_isInitialized);
+}
+
 void nnBoss_load()
 {
 	OSInitMutexEx(&nn::boss::g_mutex, nullptr);

src/Cafe/OS/libs/nn_boss/nn_boss.h

@@ -1 +1,4 @@
+void nnBoss_save(MemStreamWriter& s);
+void nnBoss_restore(MemStreamReader& s);
+
 void nnBoss_load();

src/Cafe/OS/libs/nn_fp/nn_fp.cpp

@@ -739,6 +739,18 @@ namespace nn
 			osLib_returnFromFunction(hCPU, fpdRequest->returnCode);
 		}
 
+		void save(MemStreamWriter& s)
+		{
+			s.writeSection("nn_fp");
+			s.writeData(&g_fp, sizeof(g_fp));
+		}
+
+		void restore(MemStreamReader& s)
+		{
+			s.readSection("nn_fp");
+			s.readData(&g_fp, sizeof(g_fp));
+		}
+
 		void load()
 		{
 			osLib_addFunction("nn_fp", "Initialize__Q2_2nn2fpFv", export_Initialize);

src/Cafe/OS/libs/nn_fp/nn_fp.h

@@ -3,6 +3,9 @@ namespace nn
 {
 	namespace fp
 	{
+		void save(MemStreamWriter& s);
+		void restore(MemStreamReader& s);
+
 		void load();
 	}
 }

src/Cafe/OS/libs/nn_ndm/nn_ndm.cpp

@@ -74,6 +74,20 @@ namespace nn
 			return BUILD_NN_RESULT(NN_RESULT_LEVEL_SUCCESS, NN_RESULT_MODULE_NN_NDM, 0);
 		}
 
+		void save(MemStreamWriter& s)
+		{
+			s.writeSection("nn_ndm");
+			s.writeData(s_daemonStatus, sizeof(DAEMON_STATUS) * NUM_DAEMONS);
+			s.writeBE(s_initializeRefCount);
+		}
+
+		void restore(MemStreamReader& s)
+		{
+			s.readSection("nn_ndm");
+			s.readData(s_daemonStatus, sizeof(DAEMON_STATUS) * NUM_DAEMONS);
+			s.readBE(s_initializeRefCount);
+		}
+
 		void load()
 		{
 			for(size_t i=0; i<NUM_DAEMONS; i++)

src/Cafe/OS/libs/nn_ndm/nn_ndm.h

@@ -2,6 +2,9 @@ namespace nn
 {
 	namespace ndm
 	{
+		void save(MemStreamWriter& s);
+		void restore(MemStreamReader& s);
+
 		void load();
 	}
 }

src/Cafe/OS/libs/nn_nfp/nn_nfp.cpp

@@ -1015,6 +1015,18 @@ namespace nn::nfp
 		osLib_addFunction("nn_nfp", "GetAmiiboSettingsArgs__Q2_2nn3nfpFPQ3_2nn3nfp18AmiiboSettingsArgs", nnNfpExport_GetAmiiboSettingsArgs);
 	}
 
+	void save(MemStreamWriter& s)
+	{
+		s.writeSection("nn_nfp");
+		s.writeData(&nfp_data, sizeof(nfp_data));
+	}
+
+	void restore(MemStreamReader& s)
+	{
+		s.readSection("nn_nfp");
+		s.readData(&nfp_data, sizeof(nfp_data));
+	}
+
 	void load()
 	{
 		nnNfp_load(); // legacy interface, update these to use cafeExportRegister / cafeExportRegisterFunc

src/Cafe/OS/libs/nn_nfp/nn_nfp.h

@@ -2,6 +2,9 @@
 
 namespace nn::nfp
 {
+	void save(MemStreamWriter& s);
+	void restore(MemStreamReader& s);
+
 	void load();
 }
 

src/Cafe/OS/libs/nn_olv/nn_olv.cpp

@@ -110,6 +110,40 @@ namespace nn
 
 		static_assert(GetErrorCodeImpl(0xa119c600) == 1155004);
 
+		void save(MemStreamWriter& s)
+		{
+			s.writeSection("nn_olv");
+			s.writeMPTR(s_OlvReleaseBgThread);
+			s.writeMPTR(s_OlvReleaseBgThreadStack);
+			s.writeMPTR(s_OlvReleaseBgThreadName);
+			s.writeData(&g_ParamPack, sizeof(ParamPackStorage));
+			s.writeData(&g_DiscoveryResults, sizeof(DiscoveryResultStorage));
+			s.writeBE(g_ReportTypes);
+			s.writeBool(g_IsInitialized);
+			s.writeBool(g_IsOnlineMode);
+			s.writeBool(g_IsOfflineDBMode);
+			s.writeBool(OfflineDB_Initialized());
+		}
+
+		void restore(MemStreamReader& s)
+		{
+			s.readSection("nn_olv");
+			s.readMPTR(s_OlvReleaseBgThread);
+			s.readMPTR(s_OlvReleaseBgThreadStack);
+			s.readMPTR(s_OlvReleaseBgThreadName);
+			s.readData(&g_ParamPack, sizeof(ParamPackStorage));
+			s.readData(&g_DiscoveryResults, sizeof(DiscoveryResultStorage));
+			s.readBE(g_ReportTypes);
+			s.readBool(g_IsInitialized);
+			s.readBool(g_IsOnlineMode);
+			s.readBool(g_IsOfflineDBMode);
+			if (s.readBool())
+			{
+				OfflineDB_Shutdown();
+				OfflineDB_LazyInit();
+			}
+		}
+
 		void load()
 		{
 			g_ReportTypes = 0;

src/Cafe/OS/libs/nn_olv/nn_olv.h

@@ -18,6 +18,9 @@ namespace nn
 
 		sint32 GetOlvAccessKey(uint32_t* pOutKey);
 
+		void save(MemStreamWriter& s);
+		void restore(MemStreamReader& s);
+
 		void load();
 		void unload();
 	}

src/Cafe/OS/libs/nn_olv/nn_olv_OfflineDB.cpp

@@ -17,6 +17,11 @@ namespace nn
 		bool g_offlineDBInitialized = false;
 		ZArchiveReader* g_offlineDBArchive{nullptr};
 
+		bool OfflineDB_Initialized()
+		{
+			return g_offlineDBInitialized;
+		}
+
 		void OfflineDB_LazyInit()
 		{
 			std::scoped_lock _l(g_offlineDBMutex);

src/Cafe/OS/libs/nn_olv/nn_olv_OfflineDB.h

@@ -6,7 +6,9 @@ namespace nn
 {
 	namespace olv
 	{
-		void OfflineDB_Init();
+		bool OfflineDB_Initialized();
+
+		void OfflineDB_LazyInit();
 		void OfflineDB_Shutdown();
 
 		nnResult OfflineDB_DownloadPostDataListParam_DownloadPostDataList(DownloadedTopicData* downloadedTopicData, DownloadedPostData* downloadedPostData, uint32be* postCountOut, uint32 maxCount, DownloadPostDataListParam* param);

src/Cafe/OS/libs/nn_save/nn_save.cpp

@@ -1521,6 +1521,18 @@ namespace save
 		osLib_returnFromFunction(hCPU, result);
 	}
 
+	void save(MemStreamWriter& s)
+	{
+		s.writeSection("nn_save");
+		s.writeMPTR(g_nn_save);
+	}
+
+	void restore(MemStreamReader& s)
+	{
+		s.readSection("nn_save");
+		s.readMPTR(g_nn_save);
+	}
+
 	void load()
 	{
 

src/Cafe/OS/libs/nn_save/nn_save.h

@@ -4,6 +4,9 @@ namespace nn
 {
 namespace save
 {
+	void save(MemStreamWriter& s);
+	void restore(MemStreamReader& s);
+
 	void load();
     void ResetToDefaultState();
 

src/Cafe/OS/libs/nn_temp/nn_temp.cpp

@@ -16,6 +16,18 @@ namespace nn::temp
 		osLib_returnFromFunction(hCPU, 0);
 	}
 
+	void save(MemStreamWriter& s)
+	{
+		s.writeSection("nn_temp");
+		s.writeBE(tempIdGenerator);
+	}
+
+	void restore(MemStreamReader& s)
+	{
+		s.readSection("nn_temp");
+		s.readBE(tempIdGenerator);
+	}
+
 	void Initialize()
 	{
 		osLib_addFunction("nn_temp", "TEMPCreateAndInitTempDir", nnTempExport_TEMPCreateAndInitTempDir);

src/Cafe/OS/libs/nn_temp/nn_temp.h

@@ -2,5 +2,8 @@
 
 namespace nn::temp
 {
+	void save(MemStreamWriter& s);
+	void restore(MemStreamReader& s);
+
 	void Initialize();
 };

src/Cafe/OS/libs/nn_uds/nn_uds.cpp

@@ -15,6 +15,18 @@ void nnUdsExport___sti___11_uds_Api_cpp_f5d9abb2(PPCInterpreter_t* hCPU)
 	osLib_returnFromFunction(hCPU, memory_getVirtualOffsetFromPointer(udsWorkspace));
 }
 
+void nnUds_save(MemStreamWriter& s)
+{
+	s.writeSection("nn_uds");
+	s.writeData(udsWorkspace, sizeof(udsWorkspace_t));
+}
+
+void nnUds_restore(MemStreamReader& s)
+{
+	s.readSection("nn_uds");
+	s.readData(udsWorkspace, sizeof(udsWorkspace_t));
+}
+
 /*
  * Load UDS functions
  */

src/Cafe/OS/libs/nn_uds/nn_uds.h

@@ -1 +1,4 @@
+void nnUds_save(MemStreamWriter& s);
+void nnUds_restore(MemStreamReader& s);
+
 void nnUds_load();

src/Cafe/OS/libs/nsyshid/nsyshid.cpp

@@ -813,6 +813,28 @@ namespace nsyshid
 		osLib_returnFromFunction(hCPU, 0);
 	}
 
+	void save(MemStreamWriter& s)
+	{
+		s.writeSection("nsyshid");
+		s.writeData(firstDevice, sizeof(HIDDeviceInfo_t));
+		s.writeData(firstHIDClient, sizeof(HIDClient_t));
+		s.writeBE(_lastGeneratedHidHandle);
+		s.writeMPTR(_devicePool);
+		s.writeBE(_devicePoolMask.count());
+	}
+
+	void restore(MemStreamReader& s)
+	{
+		s.readSection("nsyshid");
+		s.readData(firstDevice, sizeof(HIDDeviceInfo_t));
+		s.readData(firstHIDClient, sizeof(HIDClient_t));
+		s.readBE(_lastGeneratedHidHandle);
+		s.readMPTR(_devicePool);
+		_devicePoolMask.reset();
+		for (size_t i = 0; i < s.readBE<size_t>(); i++)
+			_devicePoolMask.set(i);
+	}
+
 	void load()
 	{
 		osLib_addFunction("nsyshid", "HIDAddClient", export_HIDAddClient);

src/Cafe/OS/libs/nsyshid/nsyshid.h

@@ -1,5 +1,8 @@
 #pragma once
 namespace nsyshid
 {
+	void save(MemStreamWriter& s);
+	void restore(MemStreamReader& s);
+
 	void load();
 }

src/Cafe/OS/libs/nsysnet/nsysnet.cpp

@@ -2161,6 +2161,32 @@ namespace nsysnet
     }
 }
 
+void nsysnet_save(MemStreamWriter& s)
+{
+	s.writeSection("nsysnet");
+	s.writeMPTR(_ntoa_tempString);
+	s.writeMPTR(_staticHostent);
+	s.writeMPTR(_staticHostentName);
+	s.writeMPTR(_staticHostentPtrList);
+	s.writeMPTR(_staticHostentEntries);
+	s.writePODVector(nsysnet::g_nsslInternalStates);
+	s.writeBool(sockLibReady);
+	s.writeData(virtualSocketTable, sizeof(virtualSocket_t) * WU_SOCKET_LIMIT);
+}
+
+void nsysnet_restore(MemStreamReader& s)
+{
+	s.readSection("nsysnet");
+	s.readMPTR(_ntoa_tempString);
+	s.readMPTR(_staticHostent);
+	s.readMPTR(_staticHostentName);
+	s.readMPTR(_staticHostentPtrList);
+	s.readMPTR(_staticHostentEntries);
+	s.readPODVector(nsysnet::g_nsslInternalStates);
+	s.readBool(sockLibReady);
+	s.readData(virtualSocketTable, sizeof(virtualSocket_t) * WU_SOCKET_LIMIT);
+}
+
 // register nsysnet functions
 void nsysnet_load()
 {

src/Cafe/OS/libs/nsysnet/nsysnet.h

@@ -12,6 +12,9 @@
 
 typedef signed int WUSOCKET;
 
+void nsysnet_save(MemStreamWriter& s);
+void nsysnet_restore(MemStreamReader& s);
+
 void nsysnet_load();
 WUSOCKET nsysnet_createVirtualSocketFromExistingSocket(SOCKET existingSocket);
 void nsysnet_notifyCloseSharedSocket(SOCKET existingSocket);

src/Cafe/OS/libs/padscore/padscore.cpp

@@ -53,7 +53,8 @@ namespace padscore
 
 	WPADState_t g_wpad_state = kWPADStateMaster;
 
-	struct {
+	struct g_padscore_t 
+	{
 		SysAllocator<coreinit::OSAlarm_t> alarm;
 		bool kpad_initialized = false;
 
@@ -746,6 +747,30 @@ 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.writeBE(g_kpad_ringbuffer_length);
+		s.writeBool(g_wpad_callback_by_kpad);
+		s.writeBE((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.readBE(g_kpad_ringbuffer_length);
+		s.readBool(g_wpad_callback_by_kpad);
+		g_wpad_state = (WPADState_t)s.readBE<uint32>();
+	}
+
 	void load()
 	{
 		cafeExportRegister("padscore", WPADIsMplsAttached, LogType::InputAPI);

src/Cafe/OS/libs/padscore/padscore.h

@@ -4,6 +4,9 @@
 
 namespace padscore
 {
+	void save(MemStreamWriter& s);
+	void restore(MemStreamReader& s);
+
 	void start();
 	void load();
 }

src/Cafe/OS/libs/proc_ui/proc_ui.cpp

@@ -49,6 +49,16 @@ void ProcUI_SendForegroundMessage()
 	}
 }
 
+void procui_save(MemStreamWriter& s)
+{
+	s.writeSection("proc_ui");
+}
+
+void procui_restore(MemStreamReader& s)
+{
+	s.readSection("proc_ui");
+}
+
 void procui_load()
 {
 	cafeExportRegister("proc_ui", ProcUIRegisterCallback, LogType::ProcUi);

src/Cafe/OS/libs/proc_ui/proc_ui.h

@@ -1,4 +1,7 @@
 
+void procui_save(MemStreamWriter& s);
+void procui_restore(MemStreamReader& s);
+
 void procui_load();
 
 void ProcUI_SendForegroundMessage();

src/util/helpers/Serializer.cpp

@@ -1,66 +1,25 @@
 #include "Serializer.h"
 
-template<>
+// readBE return
-uint8 MemStreamReader::readBE()
+
+template<typename T>
+T MemStreamReader::readBE()
 {
-	if (!reserveReadLength(sizeof(uint8)))
+	if (!reserveReadLength(sizeof(T)))
 		return 0;
-	uint8 v = m_data[m_cursorPos];
+	const uint8* p = m_data + m_cursorPos;
-	m_cursorPos += sizeof(uint8);
+	T v;
+	std::memcpy(&v, p, sizeof(v));
+	v = _BE(v);
+	m_cursorPos += sizeof(T);
 	return v;
 }
 
-template<>
+template uint8 MemStreamReader::readBE<uint8>();
-uint16 MemStreamReader::readBE()
+template uint16 MemStreamReader::readBE<uint16>();
-{
+template uint32 MemStreamReader::readBE<uint32>();
-	if (!reserveReadLength(sizeof(uint16)))
+template uint64 MemStreamReader::readBE<uint64>();
-		return 0;
+template int MemStreamReader::readBE<int>();
-	const uint8* p = m_data + m_cursorPos;
-	uint16 v;
-	std::memcpy(&v, p, sizeof(v));
-	v = _BE(v);
-	m_cursorPos += sizeof(uint16);
-	return v;
-}
-
-template<>
-uint32 MemStreamReader::readBE()
-{
-	if (!reserveReadLength(sizeof(uint32)))
-		return 0;
-	const uint8* p = m_data + m_cursorPos;
-	uint32 v;
-	std::memcpy(&v, p, sizeof(v));
-	v = _BE(v);
-	m_cursorPos += sizeof(uint32);
-	return v;
-}
-
-template<>
-sint32 MemStreamReader::readBE()
-{
-	if (!reserveReadLength(sizeof(sint32)))
-		return 0;
-	const uint8* p = m_data + m_cursorPos;
-	sint32 v;
-	std::memcpy(&v, p, sizeof(v));
-	v = _BE(v);
-	m_cursorPos += sizeof(sint32);
-	return v;
-}
-
-template<>
-uint64 MemStreamReader::readBE()
-{
-	if (!reserveReadLength(sizeof(uint64)))
-		return 0;
-	const uint8* p = m_data + m_cursorPos;
-	uint64 v;
-	std::memcpy(&v, p, sizeof(v));
-	v = _BE(v);
-	m_cursorPos += sizeof(uint64);
-	return v;
-}
 
 template<>
 std::string MemStreamReader::readBE()
@@ -80,94 +39,88 @@ std::string MemStreamReader::readBE()
 	return s;
 }
 
-template<>
+// readBE void
-uint8 MemStreamReader::readLE()
+
+template<typename T>
+void MemStreamReader::readBE(T& v)
 {
-	return readBE<uint8>();
+	if (reserveReadLength(sizeof(T)))
+	{
+		const uint8* p = m_data + m_cursorPos;
+		std::memcpy(&v, p, sizeof(v));
+		v = _BE(v);
+		m_cursorPos += sizeof(T);
+	}
 }
 
+template void MemStreamReader::readBE(uint8& v);
+template void MemStreamReader::readBE(uint16& v);
+template void MemStreamReader::readBE(uint32& v);
+template void MemStreamReader::readBE(uint64& v);
+template void MemStreamReader::readBE(int& v);
+
 template<>
-uint32 MemStreamReader::readLE()
+void MemStreamReader::readBE(std::string& v)
 {
-	if (!reserveReadLength(sizeof(uint32)))
+	uint32 stringSize = readBE<uint32>();
+	if (!hasError())
+	{
+		if (stringSize >= (32 * 1024 * 1024))
+		{
+			// out of bounds read or suspiciously large string
+			m_hasError = true;
+		}
+		else
+		{
+			v.resize(stringSize);
+			readData(v.data(), stringSize);
+		}
+	}
+}
+
+// readLE return
+
+template<typename T>
+T MemStreamReader::readLE()
+{
+	if (!reserveReadLength(sizeof(T)))
 		return 0;
 	const uint8* p = m_data + m_cursorPos;
-	uint32 v;
+	T v;
 	std::memcpy(&v, p, sizeof(v));
 	v = _LE(v);
-	m_cursorPos += sizeof(uint32);
+	m_cursorPos += sizeof(T);
 	return v;
 }
 
-template<>
+template uint8 MemStreamReader::readLE<uint8>();
-uint64 MemStreamReader::readLE()
+template uint16 MemStreamReader::readLE<uint16>();
+template uint32 MemStreamReader::readLE<uint32>();
+
+// readSection
+
+void MemStreamReader::readSection(const char* sec)
 {
-	if (!reserveReadLength(sizeof(uint64)))
+	std::string sec_str = std::string(sec);
-		return 0;
+	cemu_assert_debug(readBE<std::string>() == sec_str);
-	const uint8* p = m_data + m_cursorPos;
-	uint64 v;
-	std::memcpy(&v, p, sizeof(v));
-	v = _LE(v);
-	m_cursorPos += sizeof(uint64);
-	return v;
 }
 
-template<>
+// writeBE void
-void MemStreamWriter::writeBE<uint64>(const uint64& v)
+
+template<typename T>
+void MemStreamWriter::writeBE(const T& v)
 {
-	m_buffer.resize(m_buffer.size() + 8);
+	m_buffer.resize(m_buffer.size() + sizeof(T));
-	uint8* p = m_buffer.data() + m_buffer.size() - 8;
+	uint8* p = m_buffer.data() + m_buffer.size() - sizeof(T);
-	uint64 tmp = _BE(v);
+	T tmp = _BE(v);
 	std::memcpy(p, &tmp, sizeof(tmp));
 }
 
-template<>
+template void MemStreamWriter::writeBE(const uint8& v);
-void MemStreamWriter::writeBE<uint32>(const uint32& v)
+template void MemStreamWriter::writeBE(const uint16& v);
-{
+template void MemStreamWriter::writeBE(const uint32& v);
-	m_buffer.resize(m_buffer.size() + 4);
+template void MemStreamWriter::writeBE(const uint64& v);
-	uint8* p = m_buffer.data() + m_buffer.size() - 4;
+template void MemStreamWriter::writeBE(const int& v);
-	uint32 tmp = _BE(v);
-	std::memcpy(p, &tmp, sizeof(tmp));
-}
-
-template<>
-void MemStreamWriter::writeBE<sint32>(const sint32& v)
-{
-	m_buffer.resize(m_buffer.size() + 4);
-	uint8* p = m_buffer.data() + m_buffer.size() - 4;
-	uint32 tmp = _BE(v);
-	std::memcpy(p, &tmp, sizeof(tmp));
-}
-
-template<>
-void MemStreamWriter::writeBE<uint16>(const uint16& v)
-{
-	m_buffer.resize(m_buffer.size() + 2);
-	uint8* p = m_buffer.data() + m_buffer.size() - 2;
-	uint16 tmp = _BE(v);
-	std::memcpy(p, &tmp, sizeof(tmp));
-}
-
-
-template<>
-void MemStreamWriter::writeBE<uint8>(const uint8& v)
-{
-	m_buffer.emplace_back(v);
-}
-
-template<>
-void MemStreamWriter::writeBE<bool>(const bool& v)
-{
-	writeData(&v, sizeof(bool));
-}
-
-template<>
-bool MemStreamReader::readBE<bool>()
-{
-	bool v{ false };
-	readData(&v, sizeof(bool));
-	return v;
-}
 
 template<>
 void MemStreamWriter::writeBE<std::string>(const std::string& v)
@@ -176,21 +129,25 @@ void MemStreamWriter::writeBE<std::string>(const std::string& v)
 	writeData(v.data(), v.size());
 }
 
-template<>
+// writeLE void
-void MemStreamWriter::writeLE<uint64>(const uint64& v)
+
+template<typename T>
+void MemStreamWriter::writeLE(const T& v)
 {
-	m_buffer.resize(m_buffer.size() + 8);
+	m_buffer.resize(m_buffer.size() + sizeof(T));
-	uint8* p = m_buffer.data() + m_buffer.size() - 8;
+	uint8* p = m_buffer.data() + m_buffer.size() - sizeof(T);
-	uint64 tmp = _LE(v);
+	T tmp = _LE(v);
 	std::memcpy(p, &tmp, sizeof(tmp));
 }
 
+template void MemStreamWriter::writeLE(const uint8& v);
+template void MemStreamWriter::writeLE(const uint16& v);
+template void MemStreamWriter::writeLE(const uint32& v);
 
-template<>
+// writeSection
-void MemStreamWriter::writeLE<uint32>(const uint32& v)
+
+void MemStreamWriter::writeSection(const char* sec)
 {
-	m_buffer.resize(m_buffer.size() + 4);
+	std::string sec_str = std::string(sec);
-	uint8* p = m_buffer.data() + m_buffer.size() - 4;
+	writeBE(sec_str);
-	uint32 tmp = _LE(v);
-	std::memcpy(p, &tmp, sizeof(tmp));
 }

src/util/helpers/Serializer.h

@@ -12,6 +12,12 @@ public:
 	template<typename T> void readBE(T& v);
 	template<typename T> T readLE();
 
+	template<typename T>
+	void readAtomic(std::atomic<T>& v)
+	{
+		v.store(readBE<T>());
+	}
+
 	template<typename T>
 	std::vector<T> readPODVector()
 	{
@@ -27,6 +33,48 @@ public:
 		return v;
 	}
 
+	template<typename T>
+	void readPODVector(std::vector<T>& v)
+	{
+		uint32 numElements = readBE<uint32>();
+		if (!hasError())
+		{
+			v.reserve(numElements);
+			v.resize(numElements);
+			readData(v.data(), v.size() * sizeof(T));
+		}
+	}
+
+	template<typename T>
+	void readPTR(T& v)
+	{
+		v = (T)(memory_base + readBE<uint32>());
+	}
+
+	template<template<typename> class C, typename T>
+	void readMPTR(C<T>& v)
+	{
+		v = (T*)(memory_base + readBE<MPTR>());
+	}
+
+	template<template<typename, size_t, size_t> class C, typename T, size_t c, size_t a>
+	void readMPTR(C<T,c,a>& v)
+	{
+		v = (T*)(memory_base + readBE<MPTR>());
+	}
+
+	void readBool(bool& v)
+	{
+		v = readBE<uint8>();
+	}
+
+	bool readBool()
+	{
+		return readBE<uint8>();
+	}
+
+	void readSection(const char* sec);
+
 	// read string terminated by newline character (or end of stream)
 	// will also trim off any carriage return
 	std::string_view readLine()
@@ -71,15 +119,23 @@ public:
 
 	bool readData(void* ptr, size_t size)
 	{
-		if (m_cursorPos + size > m_size)
+		if (readBE<uint8>())
 		{
-			m_cursorPos = m_size;
+			ptr = NULL;
-			m_hasError = true;
 			return false;
 		}
-		memcpy(ptr, m_data + m_cursorPos, size);
+		else
-		m_cursorPos += (sint32)size;
+		{
-		return true;
+			if (m_cursorPos + size > m_size)
+			{
+				m_cursorPos = m_size;
+				m_hasError = true;
+				return false;
+			}
+			memcpy(ptr, m_data + m_cursorPos, size);
+			m_cursorPos += (sint32)size;
+			return true;
+		}	
 	}
 
 	std::span<uint8> readDataNoCopy(size_t size)
@@ -147,21 +203,51 @@ public:
 
 	void writeData(const void* ptr, size_t size)
 	{
-		m_buffer.resize(m_buffer.size() + size);
+		writeBE((uint8)(ptr == NULL));
-		uint8* p = m_buffer.data() + m_buffer.size() - size;
+		if (ptr)
-		memcpy(p, ptr, size);
+		{
+			m_buffer.resize(m_buffer.size() + size);
+			uint8* p = m_buffer.data() + m_buffer.size() - size;
+			memcpy(p, ptr, size);
+		}
 	}
 
 	template<typename T> void writeBE(const T& v);
 	template<typename T> void writeLE(const T& v);
+	
+	template<typename T>
+	void writeAtomic(const std::atomic<T>& v)
+	{
+		writeBE(v.load());
+	}
 
 	template<typename T>
 	void writePODVector(const std::vector<T>& v)
 	{
+		cemu_assert(std::is_trivial_v<T>);
 		writeBE<uint32>(v.size());
 		writeData(v.data(), v.size() * sizeof(T));
 	}
 
+	template<typename T>
+	void writePTR(const T& v)
+	{
+		writeBE((uint32)((uint8*)v - (uint8*)memory_base));
+	}
+
+	template<typename T>
+	void writeMPTR(const T& v)
+	{
+		writeBE(v.GetMPTR());
+	}
+
+	void writeBool(const bool& v)
+	{
+		writeBE((uint8)v);
+	}
+
+	void writeSection(const char* sec);
+
 	// get result buffer without copy
 	// resets internal state
 	void getResultAndReset(std::vector<uint8>& data)