From 35f6e67903da0b825267a0d382dd0a8f27c25558 Mon Sep 17 00:00:00 2001 From: Chris Spegal Date: Sun, 8 Oct 2023 10:34:45 -0400 Subject: [PATCH] Refactoring, save/restore additional libs --- src/Cafe/CafeSystem.cpp | 26 +- src/Cafe/Filesystem/fsc.cpp | 93 ++++--- src/Cafe/Filesystem/fsc.h | 1 - src/Cafe/Filesystem/fscDeviceHostFS.cpp | 24 +- src/Cafe/Filesystem/fscDeviceHostFS.h | 3 +- src/Cafe/Filesystem/fscDeviceWua.cpp | 10 +- src/Cafe/Filesystem/fscDeviceWud.cpp | 10 +- src/Cafe/HW/MMU/MMU.cpp | 44 +--- src/Cafe/HW/MMU/MMU.h | 3 - src/Cafe/IOSU/fsa/iosu_fsa.cpp | 142 +++++------ src/Cafe/OS/common/OSCommon.cpp | 41 ++++ src/Cafe/OS/common/OSCommon.h | 3 + src/Cafe/OS/libs/camera/camera.cpp | 26 +- src/Cafe/OS/libs/camera/camera.h | 3 + src/Cafe/OS/libs/coreinit/coreinit.cpp | 82 ++++--- src/Cafe/OS/libs/coreinit/coreinit.h | 14 +- src/Cafe/OS/libs/coreinit/coreinit_Alarm.cpp | 30 ++- src/Cafe/OS/libs/coreinit/coreinit_Alarm.h | 4 +- .../OS/libs/coreinit/coreinit_Callbacks.cpp | 62 ++--- .../OS/libs/coreinit/coreinit_CodeGen.cpp | 11 +- src/Cafe/OS/libs/coreinit/coreinit_CodeGen.h | 4 +- .../OS/libs/coreinit/coreinit_DynLoad.cpp | 20 +- src/Cafe/OS/libs/coreinit/coreinit_DynLoad.h | 4 +- src/Cafe/OS/libs/coreinit/coreinit_FG.cpp | 20 +- src/Cafe/OS/libs/coreinit/coreinit_FG.h | 4 +- src/Cafe/OS/libs/coreinit/coreinit_FS.cpp | 44 ++-- src/Cafe/OS/libs/coreinit/coreinit_FS.h | 4 +- src/Cafe/OS/libs/coreinit/coreinit_GHS.cpp | 26 +- src/Cafe/OS/libs/coreinit/coreinit_GHS.h | 4 +- src/Cafe/OS/libs/coreinit/coreinit_IPC.cpp | 40 ++- src/Cafe/OS/libs/coreinit/coreinit_IPC.h | 4 +- src/Cafe/OS/libs/coreinit/coreinit_Init.cpp | 20 +- .../OS/libs/coreinit/coreinit_LockedCache.cpp | 14 +- .../OS/libs/coreinit/coreinit_LockedCache.h | 4 +- src/Cafe/OS/libs/coreinit/coreinit_MEM.cpp | 32 ++- src/Cafe/OS/libs/coreinit/coreinit_MEM.h | 4 +- .../libs/coreinit/coreinit_MemoryMapping.cpp | 21 +- .../OS/libs/coreinit/coreinit_MemoryMapping.h | 4 +- .../libs/coreinit/coreinit_MessageQueue.cpp | 20 +- .../OS/libs/coreinit/coreinit_MessageQueue.h | 4 +- .../libs/coreinit/coreinit_OverlayArena.cpp | 16 +- .../OS/libs/coreinit/coreinit_OverlayArena.h | 4 +- .../coreinit/coreinit_Synchronization.cpp | 16 +- .../OS/libs/coreinit/coreinit_SysHeap.cpp | 16 +- src/Cafe/OS/libs/coreinit/coreinit_SysHeap.h | 4 +- .../OS/libs/coreinit/coreinit_SystemInfo.cpp | 16 +- .../OS/libs/coreinit/coreinit_SystemInfo.h | 4 +- src/Cafe/OS/libs/coreinit/coreinit_Thread.cpp | 52 ++-- src/Cafe/OS/libs/coreinit/coreinit_Thread.h | 8 +- src/Cafe/OS/libs/dmae/dmae.cpp | 11 + src/Cafe/OS/libs/dmae/dmae.h | 3 + src/Cafe/OS/libs/nlibcurl/nlibcurl.cpp | 23 ++ src/Cafe/OS/libs/nlibcurl/nlibcurl.h | 3 + src/Cafe/OS/libs/nn_acp/nn_acp.cpp | 12 + src/Cafe/OS/libs/nn_acp/nn_acp.h | 3 + src/Cafe/OS/libs/nn_act/nn_act.cpp | 13 + src/Cafe/OS/libs/nn_act/nn_act.h | 3 + src/Cafe/OS/libs/nn_aoc/nn_aoc.cpp | 15 ++ src/Cafe/OS/libs/nn_aoc/nn_aoc.h | 3 + src/Cafe/OS/libs/nn_boss/nn_boss.cpp | 16 ++ src/Cafe/OS/libs/nn_boss/nn_boss.h | 3 + src/Cafe/OS/libs/nn_fp/nn_fp.cpp | 12 + src/Cafe/OS/libs/nn_fp/nn_fp.h | 3 + src/Cafe/OS/libs/nn_ndm/nn_ndm.cpp | 14 ++ src/Cafe/OS/libs/nn_ndm/nn_ndm.h | 3 + src/Cafe/OS/libs/nn_nfp/nn_nfp.cpp | 12 + src/Cafe/OS/libs/nn_nfp/nn_nfp.h | 3 + src/Cafe/OS/libs/nn_olv/nn_olv.cpp | 34 +++ src/Cafe/OS/libs/nn_olv/nn_olv.h | 3 + src/Cafe/OS/libs/nn_olv/nn_olv_OfflineDB.cpp | 5 + src/Cafe/OS/libs/nn_olv/nn_olv_OfflineDB.h | 4 +- src/Cafe/OS/libs/nn_save/nn_save.cpp | 12 + src/Cafe/OS/libs/nn_save/nn_save.h | 3 + src/Cafe/OS/libs/nn_temp/nn_temp.cpp | 12 + src/Cafe/OS/libs/nn_temp/nn_temp.h | 3 + src/Cafe/OS/libs/nn_uds/nn_uds.cpp | 12 + src/Cafe/OS/libs/nn_uds/nn_uds.h | 3 + src/Cafe/OS/libs/nsyshid/nsyshid.cpp | 22 ++ src/Cafe/OS/libs/nsyshid/nsyshid.h | 3 + src/Cafe/OS/libs/nsysnet/nsysnet.cpp | 26 ++ src/Cafe/OS/libs/nsysnet/nsysnet.h | 3 + src/Cafe/OS/libs/padscore/padscore.cpp | 27 ++- src/Cafe/OS/libs/padscore/padscore.h | 3 + src/Cafe/OS/libs/proc_ui/proc_ui.cpp | 10 + src/Cafe/OS/libs/proc_ui/proc_ui.h | 3 + src/util/helpers/Serializer.cpp | 229 +++++++----------- src/util/helpers/Serializer.h | 104 +++++++- 87 files changed, 1024 insertions(+), 717 deletions(-) diff --git a/src/Cafe/CafeSystem.cpp b/src/Cafe/CafeSystem.cpp index 891d1738..8340a179 100644 --- a/src/Cafe/CafeSystem.cpp +++ b/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); - coreinit::ci_Alarm_Save(writer); - ci_Callbacks_Save(writer); - coreinit::ci_FS_Save(writer); - ci_Init_Save(writer); - coreinit::ci_Thread_Save(writer); + + nn::temp::save(writer); + nn::aoc::save(writer); + osLib_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); - coreinit::ci_Alarm_Restore(reader); - ci_Callbacks_Restore(reader); - coreinit::ci_FS_Restore(reader); - ci_Init_Restore(reader); - coreinit::ci_Thread_Restore(reader, recreate); + + nn::temp::restore(reader); + nn::aoc::restore(reader); + osLib_restore(reader); iosu::fsa::Restore(reader); cemuLog_log(LogType::SaveStates, "Loaded state from {}.", path); diff --git a/src/Cafe/Filesystem/fsc.cpp b/src/Cafe/Filesystem/fsc.cpp index ed7cfb00..48a2e1b7 100644 --- a/src/Cafe/Filesystem/fsc.cpp +++ b/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(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)Child::DIRECTORY_ITERATOR); + writer.writeBE(m_path); + writer.writeBE(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()) { - case Child::DIRECTORY_ITERATOR: - { - std::string path = reader.readBE(); - std::vector folders{}; - size_t size = reader.readBE(); - for (size_t i = 0; i < size; i++) + case Child::DIRECTORY_ITERATOR: { - folders.push_back(Restore(reader)); + std::string path = reader.readBE(); + std::vector folders{}; + size_t size = reader.readBE(); + for (size_t i = 0; i < size; i++) + { + folders.push_back(Restore(reader)); + } + file = new FSCVirtualFileDirectoryIterator(path, folders); + break; } - file = new FSCVirtualFileDirectoryIterator(path, folders); - break; + case Child::HOST: + { + std::string path = reader.readBE(); + FSC_ACCESS_FLAG flags = (FSC_ACCESS_FLAG)reader.readBE(); + sint32 status{}; + file = FSCVirtualFile_Host::OpenFile(path, flags, status); + file->fscSetSeek(reader.readBE()); + break; + } + default: + throw std::exception("Not implemented"); } - case Child::HOST: - { - std::string path = reader.readBE(); - FSC_ACCESS_FLAG flags = (FSC_ACCESS_FLAG)reader.readBE(); - sint32 status{}; - file = FSCVirtualFile_Host::OpenFile(path, flags, status); - file->fscSetSeek(reader.readBE()); - break; - } - default: - throw std::exception("Not implemented"); - } - if (reader.readBE()) + if (reader.readBool()) { file->dirIterator = new FSCDirIteratorState; - *file->dirIterator = reader.readBE(); + reader.readBE(*file->dirIterator); } + reader.readBool(file->m_isAppend); return file; -} - -void FSCVirtualFileDirectoryIterator::Save(MemStreamWriter& writer) -{ - writer.writeBE((uint32)Child::DIRECTORY_ITERATOR); - writer.writeBE(m_path); - writer.writeBE(m_folders.size()); - for (auto& folder : m_folders) - { - folder->Save(writer); - } - FSCVirtualFile::Save(writer); } \ No newline at end of file diff --git a/src/Cafe/Filesystem/fsc.h b/src/Cafe/Filesystem/fsc.h index b3b66d04..8d9ab032 100644 --- a/src/Cafe/Filesystem/fsc.h +++ b/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) diff --git a/src/Cafe/Filesystem/fscDeviceHostFS.cpp b/src/Cafe/Filesystem/fscDeviceHostFS.cpp index 7f66c99b..12b15024 100644 --- a/src/Cafe/Filesystem/fscDeviceHostFS.cpp +++ b/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)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; -} \ No newline at end of file +} + +void FSCVirtualFile_Host::Save(MemStreamWriter& writer) +{ + writer.writeBE((uint32)Child::HOST); + writer.writeBE(m_path->string()); + writer.writeBE((uint32)m_accessFlags); + writer.writeBE(m_seek); + FSCVirtualFile::Save(writer); +} diff --git a/src/Cafe/Filesystem/fscDeviceHostFS.h b/src/Cafe/Filesystem/fscDeviceHostFS.h index 6daab151..0a7df4cd 100644 --- a/src/Cafe/Filesystem/fscDeviceHostFS.h +++ b/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) {}; diff --git a/src/Cafe/Filesystem/fscDeviceWua.cpp b/src/Cafe/Filesystem/fscDeviceWua.cpp index 5bea3715..e5f23a9e 100644 --- a/src/Cafe/Filesystem/fscDeviceWua.cpp +++ b/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; diff --git a/src/Cafe/Filesystem/fscDeviceWud.cpp b/src/Cafe/Filesystem/fscDeviceWud.cpp index 70d9b5c9..537699b7 100644 --- a/src/Cafe/Filesystem/fscDeviceWud.cpp +++ b/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; diff --git a/src/Cafe/HW/MMU/MMU.cpp b/src/Cafe/HW/MMU/MMU.cpp index 508b9cc2..e65e62f9 100644 --- a/src/Cafe/HW/MMU/MMU.cpp +++ b/src/Cafe/HW/MMU/MMU.cpp @@ -80,37 +80,22 @@ MMURange* memory_getMMURangeByAddress(MPTR address) return nullptr; } -bool MMURange::serializeImpl(MemStreamWriter& streamWriter) -{ - streamWriter.writeBE(this->m_isMapped); - if (m_isMapped) - { - streamWriter.writeBE(this->baseAddress); - streamWriter.writeBE((uint8)this->areaId); - streamWriter.writeBE((uint8)this->flags); - streamWriter.writeBE(this->name); - streamWriter.writeBE(this->size); - streamWriter.writeBE(this->initSize); - } - return true; -} - template<> -void MemStreamWriter::writeBE(const MMURange& v) +void MemStreamWriter::writeBE(const MMURange& v) { - writeBE(v.m_isMapped); + writeBool(v.m_isMapped); writeBE(v.baseAddress); - writeBE((uint8)v.areaId); - writeBE((uint8)v.flags); + writeBE((uint8)v.areaId); + writeBE((uint8)v.flags); writeBE(v.name); writeBE(v.size); writeBE(v.initSize); } template <> -void MemStreamReader::readBE(MMURange& mmuRange) +void MemStreamReader::readBE(MMURange& mmuRange) { - bool needsMapped = readBE(); + bool needsMapped = readBool(); mmuRange.m_isMapped = false; mmuRange.baseAddress = readBE(); mmuRange.areaId = (MMU_MEM_AREA_ID)readBE(); @@ -122,23 +107,6 @@ void MemStreamReader::readBE(MMURange& mmuRange) mmuRange.mapMem(); } -bool MMURange::deserializeImpl(MemStreamReader& streamReader) -{ - m_isMapped = streamReader.readBE(); - if (m_isMapped) - { - baseAddress = streamReader.readBE(); - areaId = (MMU_MEM_AREA_ID)streamReader.readBE(); - this->flags = (MFLAG)streamReader.readBE(); - this->name = streamReader.readBE(); - this->size = streamReader.readBE(); - this->initSize = streamReader.readBE(); - 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); diff --git a/src/Cafe/HW/MMU/MMU.h b/src/Cafe/HW/MMU/MMU.h index 216b4109..3090e3c9 100644 --- a/src/Cafe/HW/MMU/MMU.h +++ b/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(); diff --git a/src/Cafe/IOSU/fsa/iosu_fsa.cpp b/src/Cafe/IOSU/fsa/iosu_fsa.cpp index 903aa881..fdb7dee4 100644 --- a/src/Cafe/IOSU/fsa/iosu_fsa.cpp +++ b/src/Cafe/IOSU/fsa/iosu_fsa.cpp @@ -36,7 +36,9 @@ namespace iosu } }; - std::array sFSAClientArray; + static constexpr int const sFSAClientArraySize = 624; + + std::array 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(const FSCDirEntry& v); -template <> -FSCDirEntry MemStreamReader::readBE(); -template <> -FSCVirtualFile::FSCDirIteratorState MemStreamReader::readBE(); -template <> -void MemStreamWriter::writeBE(const FSCVirtualFile::FSCDirIteratorState& v); +void MemStreamWriter::writeBE(const iosu::fsa::FSAClient& v) +{ + writeBE(v.workingDirectory); + writeBool(v.isAllocated); +} template <> -void MemStreamWriter::writeBE(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); - writeBE(v.m_handleTable[i].fscFile != nullptr); + writeBool(v.m_handleTable[i].isAllocated); + + 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() +void MemStreamReader::readBE(iosu::fsa::_FSAHandleTable& v) { - iosu::fsa::_FSAHandleTable table{}; - table.m_currentCounter = readBE(); - for (int i = 0; i < 0x3C0; i++) + readBE(v.m_currentCounter); + for (sint32 i = 0; i < v.m_handleTableSize; i++) { - table.m_handleTable[i].handleCheckValue = readBE(); - table.m_handleTable[i].isAllocated = readBE(); - if (readBE()) table.m_handleTable[i].fscFile = FSCVirtualFile::Restore(*this); - } - return table; -} + readBE(v.m_handleTable[i].handleCheckValue); + readBool(v.m_handleTable[i].isAllocated); -template <> -void MemStreamWriter::writeBE(const FSCVirtualFile::FSCDirIteratorState& v) -{ - writeBE(v.index); - writeBE(v.dirEntries.size()); - for (int i = 0; i < v.dirEntries.size(); i++) - { - writeBE(v.dirEntries[i]); + if (readBool()) v.m_handleTable[i].fscFile = FSCVirtualFile::Restore(*this); } } -template <> -void MemStreamWriter::writeBE(const FSCDirEntry& v) +namespace iosu { - writeData(v.path, FSC_MAX_DIR_NAME_LENGTH); - writeBE(v.isDirectory); - writeBE(v.isFile); - writeBE(v.fileSize); -} - -template <> -FSCDirEntry MemStreamReader::readBE() -{ - FSCDirEntry entry{}; - readData(entry.path, FSC_MAX_DIR_NAME_LENGTH); - entry.isDirectory = readBE(); - entry.isFile = readBE(); - entry.fileSize = readBE(); - return entry; -} - -template <> -FSCVirtualFile::FSCDirIteratorState MemStreamReader::readBE() -{ - FSCVirtualFile::FSCDirIteratorState state{}; - state.index = readBE(); - size_t size = readBE(); - for (size_t i = 0; i < size; i++) + namespace fsa { - state.dirEntries[i] = readBE(); - } - 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++) + void Save(MemStreamWriter& s) { - 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) - { - char section[16] = { '\0' }; - reader.readData(section, 15); - cemu_assert_debug(strcmp(section, "iosu_fsa_S") == 0); - - sFSAIoMsgQueue = reader.readBE(); - for (size_t i = 0; i < 352; i++) + void Restore(MemStreamReader& s) { - _m_sFSAIoMsgQueueMsgBuffer[i] = reader.readBE(); + 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>(); - sFileHandleTable = reader.readBE<_FSAHandleTable>(); - } -} \ No newline at end of file + } // namespace fsa +} // namespace iosu \ No newline at end of file diff --git a/src/Cafe/OS/common/OSCommon.cpp b/src/Cafe/OS/common/OSCommon.cpp index 7e11ea13..29379f61 100644 --- a/src/Cafe/OS/common/OSCommon.cpp +++ b/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 diff --git a/src/Cafe/OS/common/OSCommon.h b/src/Cafe/OS/common/OSCommon.h index 4fb65a47..04f3b4f4 100644 --- a/src/Cafe/OS/common/OSCommon.h +++ b/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); diff --git a/src/Cafe/OS/libs/camera/camera.cpp b/src/Cafe/OS/libs/camera/camera.cpp index 4debb37f..c9b5cbc8 100644 --- a/src/Cafe/OS/libs/camera/camera.cpp +++ b/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 _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); } -} - +} \ No newline at end of file diff --git a/src/Cafe/OS/libs/camera/camera.h b/src/Cafe/OS/libs/camera/camera.h index 04248bbc..6b3d48b1 100644 --- a/src/Cafe/OS/libs/camera/camera.h +++ b/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(); }; \ No newline at end of file diff --git a/src/Cafe/OS/libs/coreinit/coreinit.cpp b/src/Cafe/OS/libs/coreinit/coreinit.cpp index ce2588bc..e573c11d 100644 --- a/src/Cafe/OS/libs/coreinit/coreinit.cpp +++ b/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; - 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); + coreinit_Init_Save(s); + coreinit::SysHeap_Save(s); + coreinit::Thread_Save(s); + coreinit::MEM_Save(s); + coreinit::FG_Save(s); + coreinit::OverlayArena_Save(s); + coreinit::DynLoad_Save(s); + coreinit::GHS_Save(s); + coreinit::LockedCache_Save(s); + coreinit::Alarm_Save(s); + coreinit::FS_Save(s); + coreinit::SystemInfo_Save(s); + coreinit::Synchronization_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.readData(section, 15); - cemu_assert_debug(strcmp(section, "ci_S") == 0); + s.readSection("coreinit"); + + bool recreate = false; + if (recreate) + coreinit::__OSDeleteAllActivePPCThreads(); s.readData(gCoreinitData, sizeof(coreinitData_t)); - placeholderFont = s.readBE(); - placeholderFontSize = s.readBE(); + s.readBE(placeholderFont); + s.readBE(placeholderFontSize); - 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); + coreinit_Init_Restore(s); + coreinit::SysHeap_Restore(s); + coreinit::Thread_Restore(s, recreate); + coreinit::MEM_Restore(s); + coreinit::FG_Restore(s); + coreinit::OverlayArena_Restore(s); + coreinit::DynLoad_Restore(s); + coreinit::GHS_Restore(s); + coreinit::LockedCache_Restore(s); + coreinit::Alarm_Restore(s); + coreinit::FS_Restore(s); + coreinit::SystemInfo_Restore(s); + coreinit::Synchronization_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() diff --git a/src/Cafe/OS/libs/coreinit/coreinit.h b/src/Cafe/OS/libs/coreinit/coreinit.h index 81d80f08..c15cbe6d 100644 --- a/src/Cafe/OS/libs/coreinit/coreinit.h +++ b/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 ci_Callbacks_Restore(MemStreamReader& s); +void coreinit_Callbacks_Save(MemStreamWriter& 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 ci_Restore(MemStreamReader& s); +void coreinit_load(); // 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 ci_Init_Restore(MemStreamReader& s); +void coreinit_Init_Save(MemStreamWriter& s); +void coreinit_Init_Restore(MemStreamReader& s); MPTR OSAllocFromSystem(uint32 size, uint32 alignment); void OSFreeToSystem(MPTR mem); diff --git a/src/Cafe/OS/libs/coreinit/coreinit_Alarm.cpp b/src/Cafe/OS/libs/coreinit/coreinit_Alarm.cpp index d379d49c..bfc975fc 100644 --- a/src/Cafe/OS/libs/coreinit/coreinit_Alarm.cpp +++ b/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.writeBE(g_alarmThread.GetMPTR()); - s.writeBE(_g_alarmThreadStack.GetMPTR()); - s.writeBE(_g_alarmThreadName.GetMPTR()); + s.writeMPTR(g_alarmEvent); + s.writeMPTR(g_alarmThread); + s.writeMPTR(_g_alarmThreadStack); + 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.readData(section, 15); - cemu_assert_debug(strcmp(section, "ci_A_S") == 0); + s.readSection("coreinit_Alarm"); - g_alarmEvent = (OSEvent*)memory_getPointerFromVirtualOffset(s.readBE()); - g_alarmThread = (OSThread_t*)memory_getPointerFromVirtualOffset(s.readBE()); - _g_alarmThreadStack = (uint8*)memory_getPointerFromVirtualOffset(s.readBE()); - _g_alarmThreadName = (char*)memory_getPointerFromVirtualOffset(s.readBE()); + s.readMPTR(g_alarmEvent); + s.readMPTR(g_alarmThread); + s.readMPTR(_g_alarmThreadStack); + s.readMPTR(_g_alarmThreadName); uint64 currentTime = coreinit_getOSTime(); uint64_t timeOffset = currentTime - s.readBE(); - size_t alms = s.readBE(); + size_t alms = s.readBE(); for (size_t alm = 0; alm < alms; alm++) { OSAlarm_t* alarm = (OSAlarm_t*)memory_getPointerFromVirtualOffset(s.readBE()); diff --git a/src/Cafe/OS/libs/coreinit/coreinit_Alarm.h b/src/Cafe/OS/libs/coreinit/coreinit_Alarm.h index 93523d68..5b75570f 100644 --- a/src/Cafe/OS/libs/coreinit/coreinit_Alarm.h +++ b/src/Cafe/OS/libs/coreinit/coreinit_Alarm.h @@ -47,8 +47,8 @@ namespace coreinit void OSAlarm_Shutdown(); - void ci_Alarm_Save(MemStreamWriter& s); - void ci_Alarm_Restore(MemStreamReader& s); + void Alarm_Save(MemStreamWriter& s); + void Alarm_Restore(MemStreamReader& s); void alarm_update(); diff --git a/src/Cafe/OS/libs/coreinit/coreinit_Callbacks.cpp b/src/Cafe/OS/libs/coreinit/coreinit_Callbacks.cpp index 9507249d..e080c3cb 100644 --- a/src/Cafe/OS/libs/coreinit/coreinit_Callbacks.cpp +++ b/src/Cafe/OS/libs/coreinit/coreinit_Callbacks.cpp @@ -31,14 +31,14 @@ struct CoreinitAsyncCallback s_asyncCallbackSpinlock.unlock(); } - static std::vector* getPoolPtr() + static std::vector& getPool() { - return &s_asyncCallbackPool; + return s_asyncCallbackPool; } - static std::vector* getQueuePtr() + static std::vector& 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.writeBE(g_coreinitCallbackThread.GetMPTR()); - s.writeBE(_g_coreinitCallbackThreadStack.GetMPTR()); - s.writeBE(g_asyncCallbackAsync.GetMPTR()); - s.writeBE(_g_coreinitCBThreadName.GetMPTR()); - - std::vector* pool = CoreinitAsyncCallback::getPoolPtr(); - size_t poolSize = pool->size(); - s.writeBE(poolSize); - s.writeData(pool, sizeof(CoreinitAsyncCallback) * poolSize); - - std::vector* queue = CoreinitAsyncCallback::getQueuePtr(); - size_t queueSize = queue->size(); - s.writeBE(queueSize); - s.writeData(queue, sizeof(CoreinitAsyncCallback) * queueSize); + s.writeSection("coreinit_Callbacks"); + s.writeMPTR(g_coreinitCallbackThread); + s.writeMPTR(_g_coreinitCallbackThreadStack); + s.writeMPTR(g_asyncCallbackAsync); + s.writeMPTR(_g_coreinitCBThreadName); + s.writePODVector(CoreinitAsyncCallback::getPool()); + s.writePODVector(CoreinitAsyncCallback::getQueue()); } -void ci_Callbacks_Restore(MemStreamReader& s) +void coreinit_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()); - _g_coreinitCallbackThreadStack = (uint8*)memory_getPointerFromVirtualOffset(s.readBE()); - g_asyncCallbackAsync = (coreinit::OSSemaphore*)memory_getPointerFromVirtualOffset(s.readBE()); - _g_coreinitCBThreadName = (char*)memory_getPointerFromVirtualOffset(s.readBE()); - - std::vector* pool = CoreinitAsyncCallback::getPoolPtr(); - size_t poolSize = s.readBE(); - pool->clear(); - pool->resize(poolSize); - s.readData(pool, sizeof(CoreinitAsyncCallback) * poolSize); - - std::vector* queue = CoreinitAsyncCallback::getPoolPtr(); - size_t queueSize = s.readBE(); - queue->clear(); - queue->resize(queueSize); - s.readData(queue, sizeof(CoreinitAsyncCallback) * queueSize); + s.readSection("coreinit_Callbacks"); + s.readMPTR(g_coreinitCallbackThread); + s.readMPTR(_g_coreinitCallbackThreadStack); + s.readMPTR(g_asyncCallbackAsync); + s.readMPTR(_g_coreinitCBThreadName); + s.readPODVector(CoreinitAsyncCallback::getPool()); + s.readPODVector(CoreinitAsyncCallback::getQueue()); } void InitializeAsyncCallback() diff --git a/src/Cafe/OS/libs/coreinit/coreinit_CodeGen.cpp b/src/Cafe/OS/libs/coreinit/coreinit_CodeGen.cpp index c27c1a52..7fea2b46 100644 --- a/src/Cafe/OS/libs/coreinit/coreinit_CodeGen.cpp +++ b/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.readData(section, 15); - cemu_assert_debug(strcmp(section, "ci_CG_S") == 0); - + s.readSection("coreinit_CodeGen"); s.readData(&coreinitCodeGen, sizeof(coreinitCodeGen)); } diff --git a/src/Cafe/OS/libs/coreinit/coreinit_CodeGen.h b/src/Cafe/OS/libs/coreinit/coreinit_CodeGen.h index f7bdff04..ffc4ad68 100644 --- a/src/Cafe/OS/libs/coreinit/coreinit_CodeGen.h +++ b/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 ci_CodeGen_Restore(MemStreamReader& s); + void CodeGen_Save(MemStreamWriter& s); + void CodeGen_Restore(MemStreamReader& s); void InitializeCodeGen(); } \ No newline at end of file diff --git a/src/Cafe/OS/libs/coreinit/coreinit_DynLoad.cpp b/src/Cafe/OS/libs/coreinit/coreinit_DynLoad.cpp index 4a3db30e..35e1447c 100644 --- a/src/Cafe/OS/libs/coreinit/coreinit_DynLoad.cpp +++ b/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.readData(section, 15); - cemu_assert_debug(strcmp(section, "ci_DL_S") == 0); - - _osDynLoadFuncAlloc = s.readBE(); - _osDynLoadFuncFree = s.readBE(); - _osDynLoadTLSFuncAlloc = s.readBE(); - _osDynLoadTLSFuncFree = s.readBE(); + s.readSection("coreinit_DynLoad"); + s.readBE(_osDynLoadFuncAlloc); + s.readBE(_osDynLoadFuncFree); + s.readBE(_osDynLoadTLSFuncAlloc); + s.readBE(_osDynLoadTLSFuncFree); } void InitializeDynLoad() diff --git a/src/Cafe/OS/libs/coreinit/coreinit_DynLoad.h b/src/Cafe/OS/libs/coreinit/coreinit_DynLoad.h index c31040a9..8eaa4bcb 100644 --- a/src/Cafe/OS/libs/coreinit/coreinit_DynLoad.h +++ b/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* addrOut); - void ci_DynLoad_Save(MemStreamWriter& s); - void ci_DynLoad_Restore(MemStreamReader& s); + void DynLoad_Save(MemStreamWriter& s); + void DynLoad_Restore(MemStreamReader& s); void InitializeDynLoad(); } \ No newline at end of file diff --git a/src/Cafe/OS/libs/coreinit/coreinit_FG.cpp b/src/Cafe/OS/libs/coreinit/coreinit_FG.cpp index 457aa01e..1aead0ca 100644 --- a/src/Cafe/OS/libs/coreinit/coreinit_FG.cpp +++ b/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.writeBE(fgAddr.GetMPTR()); - s.writeBE(fgSaveAreaAddr.GetMPTR()); + s.writeSection("coreinit_FG"); + s.writeMPTR(fgAddr); + s.writeMPTR(fgSaveAreaAddr); 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.readData(section, 15); - cemu_assert_debug(strcmp(section, "ci_FG_S") == 0); - - fgAddr = memory_getPointerFromVirtualOffset(s.readBE()); - fgSaveAreaAddr = memory_getPointerFromVirtualOffset(s.readBE()); + s.readSection("coreinit_FG"); + s.readMPTR(fgAddr); + s.readMPTR(fgSaveAreaAddr); s.readData(&fgAreaEntries, sizeof(fgAreaEntries) * FG_BUCKET_AREA_COUNT); } diff --git a/src/Cafe/OS/libs/coreinit/coreinit_FG.h b/src/Cafe/OS/libs/coreinit/coreinit_FG.h index fcc88b4f..07f272d0 100644 --- a/src/Cafe/OS/libs/coreinit/coreinit_FG.h +++ b/src/Cafe/OS/libs/coreinit/coreinit_FG.h @@ -13,8 +13,8 @@ namespace coreinit void InitForegroundBucket(); - void ci_FG_Save(MemStreamWriter& s); - void ci_FG_Restore(MemStreamReader& s); + void FG_Save(MemStreamWriter& s); + void FG_Restore(MemStreamReader& s); void InitializeFG(); } \ No newline at end of file diff --git a/src/Cafe/OS/libs/coreinit/coreinit_FS.cpp b/src/Cafe/OS/libs/coreinit/coreinit_FS.cpp index c230d14f..ca840517 100644 --- a/src/Cafe/OS/libs/coreinit/coreinit_FS.cpp +++ b/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.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()); + s.writeBool(_sdCard01Mounted); + s.writeBool(_mlc01Mounted); + s.writeMPTR(_tempFSSpace); + s.writePODVector(s_fsa_activeClients); + s.writeMPTR(s_fsaIpcPool); + s.writeMPTR(s_fsaIpcPoolBuffer); + s.writeMPTR(s_fsaIpcPoolBufferNumItems); } - void ci_FS_Restore(MemStreamReader& s) + void FS_Restore(MemStreamReader& s) { - char section[16] = { '\0' }; - s.readData(section, 15); - cemu_assert_debug(strcmp(section, "ci_FS_S") == 0); - + s.readSection("coreinit_FS"); s.readData(g_fsRegisteredClientBodies, sizeof(FSClientBody_t)); - _sdCard01Mounted = s.readBE(); - _mlc01Mounted = s.readBE(); - _tempFSSpace = memory_getPointerFromVirtualOffset(s.readBE()); - size_t s_fsa_activeClients_size = s.readBE(); - 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()); - s_fsaIpcPoolBuffer = memory_getPointerFromVirtualOffset(s.readBE()); - s_fsaIpcPoolBufferNumItems = (uint32be*)memory_getPointerFromVirtualOffset(s.readBE()); + s.readBool(_sdCard01Mounted); + s.readBool(_mlc01Mounted); + s.readMPTR(_tempFSSpace); + s.readPODVector(s_fsa_activeClients); + s.readMPTR(s_fsaIpcPool); + s.readMPTR(s_fsaIpcPoolBuffer); + s.readMPTR(s_fsaIpcPoolBufferNumItems); } void InitializeFS() diff --git a/src/Cafe/OS/libs/coreinit/coreinit_FS.h b/src/Cafe/OS/libs/coreinit/coreinit_FS.h index 0b576126..7a9fc72c 100644 --- a/src/Cafe/OS/libs/coreinit/coreinit_FS.h +++ b/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 ci_FS_Restore(MemStreamReader& s); + void FS_Save(MemStreamWriter& s); + void FS_Restore(MemStreamReader& s); void InitializeFS(); }; // namespace coreinit diff --git a/src/Cafe/OS/libs/coreinit/coreinit_GHS.cpp b/src/Cafe/OS/libs/coreinit/coreinit_GHS.cpp index f967781f..d17b466c 100644 --- a/src/Cafe/OS/libs/coreinit/coreinit_GHS.cpp +++ b/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.writeBE(g_ghs_data.GetMPTR()); - s.writeBE(_flockMutexArray.GetMPTR()); - s.writeData(_flockMutexMask, sizeof(bool) * GHS_FOPEN_MAX); + s.writeSection("coreinit_GHS"); + s.writeMPTR(g_ghs_data); + s.writeMPTR(_flockMutexArray); + s.writeData(reinterpret_cast(_flockMutexMask), sizeof(uint8) * GHS_FOPEN_MAX); } - void ci_GHS_Restore(MemStreamReader& s) + void 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()); - _flockMutexArray = (coreinit::OSMutex*)memory_getPointerFromVirtualOffset(s.readBE()); - s.readData(_flockMutexMask, sizeof(bool) * GHS_FOPEN_MAX); + s.readSection("coreinit_GHS"); + s.readMPTR(g_ghs_data); + s.readMPTR(_flockMutexArray); + uint8 _flockMutexMaskTmp[GHS_FOPEN_MAX] = { 0 }; + s.readData(_flockMutexMaskTmp, sizeof(uint8) * GHS_FOPEN_MAX); + memcpy(_flockMutexMask, reinterpret_cast(_flockMutexMaskTmp), sizeof(bool) * GHS_FOPEN_MAX); } void InitializeGHS() diff --git a/src/Cafe/OS/libs/coreinit/coreinit_GHS.h b/src/Cafe/OS/libs/coreinit/coreinit_GHS.h index 3cc64445..fbef43c7 100644 --- a/src/Cafe/OS/libs/coreinit/coreinit_GHS.h +++ b/src/Cafe/OS/libs/coreinit/coreinit_GHS.h @@ -4,8 +4,8 @@ namespace coreinit { void PrepareGHSRuntime(); - void ci_GHS_Save(MemStreamWriter& s); - void ci_GHS_Restore(MemStreamReader& s); + void GHS_Save(MemStreamWriter& s); + void GHS_Restore(MemStreamReader& s); void InitializeGHS(); }; \ No newline at end of file diff --git a/src/Cafe/OS/libs/coreinit/coreinit_IPC.cpp b/src/Cafe/OS/libs/coreinit/coreinit_IPC.cpp index 6a582203..75ef6131 100644 --- a/src/Cafe/OS/libs/coreinit/coreinit_IPC.cpp +++ b/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.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()); + s.writeSection("coreinit_IPC"); + s.writeMPTR(s_ipcResourceBuffers); + s.writeMPTR(s_ipcDriver); + s.writeMPTR(gIPCThread); + s.writeMPTR(_gIPCThreadStack); + s.writeMPTR(_gIPCThreadNameStorage); + s.writeMPTR(gIPCThreadMsgQueue); + s.writeMPTR(_gIPCThreadSemaphoreStorage); } - void ci_IPC_Restore(MemStreamReader& s) + void 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()); - s_ipcDriver = (IPCDriver*)memory_getPointerFromVirtualOffset(s.readBE()); - gIPCThread = (OSThread_t*)memory_getPointerFromVirtualOffset(s.readBE()); - _gIPCThreadStack = memory_getPointerFromVirtualOffset(s.readBE()); - _gIPCThreadNameStorage = memory_getPointerFromVirtualOffset(s.readBE()); - gIPCThreadMsgQueue = (OSMessageQueue*)memory_getPointerFromVirtualOffset(s.readBE()); - _gIPCThreadSemaphoreStorage = (OSMessage*)memory_getPointerFromVirtualOffset(s.readBE()); + s.readSection("coreinit_IPC"); + s.readMPTR(s_ipcResourceBuffers); + s.readMPTR(s_ipcDriver); + s.readMPTR(gIPCThread); + s.readMPTR(_gIPCThreadStack); + s.readMPTR(_gIPCThreadNameStorage); + s.readMPTR(gIPCThreadMsgQueue); + s.readMPTR(_gIPCThreadSemaphoreStorage); } void InitializeIPC() diff --git a/src/Cafe/OS/libs/coreinit/coreinit_IPC.h b/src/Cafe/OS/libs/coreinit/coreinit_IPC.h index f379773e..dc20dcfb 100644 --- a/src/Cafe/OS/libs/coreinit/coreinit_IPC.h +++ b/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 asyncResultFunc, MEMPTR asyncResultUserParam); - void ci_IPC_Save(MemStreamWriter& s); - void ci_IPC_Restore(MemStreamReader& s); + void IPC_Save(MemStreamWriter& s); + void IPC_Restore(MemStreamReader& s); void InitializeIPC(); }; \ No newline at end of file diff --git a/src/Cafe/OS/libs/coreinit/coreinit_Init.cpp b/src/Cafe/OS/libs/coreinit/coreinit_Init.cpp index 591a3c61..0d7cb477 100644 --- a/src/Cafe/OS/libs/coreinit/coreinit_Init.cpp +++ b/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.readData(section, 15); - cemu_assert_debug(strcmp(section, "ci_Init_S") == 0); - + s.readSection("coreinit_Init"); s.readData(_coreinitInfo, sizeof(coreinitInit_t)); - argStorageIndex = s.readBE(); - g_preinitUserParam = (PreinitUserHeapStruct*)memory_getPointerFromVirtualOffset(s.readBE()); - _coreinitTitleEntryPoint = s.readBE(); + s.readBE(argStorageIndex); + s.readMPTR(g_preinitUserParam); + s.readBE(_coreinitTitleEntryPoint); } \ No newline at end of file diff --git a/src/Cafe/OS/libs/coreinit/coreinit_LockedCache.cpp b/src/Cafe/OS/libs/coreinit/coreinit_LockedCache.cpp index b330f979..05fd1645 100644 --- a/src/Cafe/OS/libs/coreinit/coreinit_LockedCache.cpp +++ b/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.readData(section, 15); - cemu_assert_debug(strcmp(section, "ci_LC_S") == 0); - + s.readSection("coreinit_LockedCache"); 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(); + s.readBE(_lcDisableErrorCounter); } void InitializeLC() diff --git a/src/Cafe/OS/libs/coreinit/coreinit_LockedCache.h b/src/Cafe/OS/libs/coreinit/coreinit_LockedCache.h index 89d2b11c..3ef21993 100644 --- a/src/Cafe/OS/libs/coreinit/coreinit_LockedCache.h +++ b/src/Cafe/OS/libs/coreinit/coreinit_LockedCache.h @@ -2,8 +2,8 @@ namespace coreinit { - void ci_LockedCache_Save(MemStreamWriter& s); - void ci_LockedCache_Restore(MemStreamReader& s); + void LockedCache_Save(MemStreamWriter& s); + void LockedCache_Restore(MemStreamReader& s); void InitializeLC(); } \ No newline at end of file diff --git a/src/Cafe/OS/libs/coreinit/coreinit_MEM.cpp b/src/Cafe/OS/libs/coreinit/coreinit_MEM.cpp index cfbeee5e..e7594de1 100644 --- a/src/Cafe/OS/libs/coreinit/coreinit_MEM.cpp +++ b/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.writeBE(g_listsInitialized); + s.writeBool(g_slockInitialized); + 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.readData(section, 15); - cemu_assert_debug(strcmp(section, "ci_MEM_S") == 0); - - sysAreaAllocatorOffset = s.readBE(); - g_heapTableCount = s.readBE(); + s.readSection("coreinit_MEM"); + s.readBE(sysAreaAllocatorOffset); + s.readBE(g_heapTableCount); s.readData(g_heapTable, sizeof(MEMHeapBase) * MEM_MAX_HEAP_TABLE); - g_slockInitialized = s.readBE(); - g_listsInitialized = s.readBE(); + s.readBool(g_slockInitialized); + 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()); + s.readMPTR(gHeapGlobalLock); s.readData(&gDefaultHeap, sizeof(MEMHeapBase)); s.readData(&sHeapBaseHandle, sizeof(MEMHeapBase) * 9); - gDefaultHeapAllocator = (MEMAllocatorFunc*)memory_getPointerFromVirtualOffset(s.readBE()); + s.readMPTR(gDefaultHeapAllocator); } void InitializeMEM() diff --git a/src/Cafe/OS/libs/coreinit/coreinit_MEM.h b/src/Cafe/OS/libs/coreinit/coreinit_MEM.h index f057fa0f..7420fe5b 100644 --- a/src/Cafe/OS/libs/coreinit/coreinit_MEM.h +++ b/src/Cafe/OS/libs/coreinit/coreinit_MEM.h @@ -179,8 +179,8 @@ namespace coreinit void InitializeMEMUnitHeap(); - void ci_MEM_Save(MemStreamWriter& s); - void ci_MEM_Restore(MemStreamReader& s); + void MEM_Save(MemStreamWriter& s); + void MEM_Restore(MemStreamReader& s); void InitializeMEM(); } diff --git a/src/Cafe/OS/libs/coreinit/coreinit_MemoryMapping.cpp b/src/Cafe/OS/libs/coreinit/coreinit_MemoryMapping.cpp index cfeb94b7..fbdc366f 100644 --- a/src/Cafe/OS/libs/coreinit/coreinit_MemoryMapping.cpp +++ b/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); - - size_t s_allocatedVirtMemorySize = s_allocatedVirtMemory.size(); - s.writeBE(s_allocatedVirtMemorySize); - s.writeData(&s_allocatedVirtMemory, sizeof(OSVirtMemoryEntry) * s_allocatedVirtMemorySize); + s.writeSection("coreinit_MemoryMapping "); + s.writePODVector(s_allocatedVirtMemory); } - void ci_MemoryMapping_Restore(MemStreamReader& s) + void 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(); - s_allocatedVirtMemory.clear(); - s_allocatedVirtMemory.resize(s_allocatedVirtMemorySize); - s.readData(&s_allocatedVirtMemory, sizeof(OSVirtMemoryEntry) * s_allocatedVirtMemorySize); + s.readSection("coreinit_MemoryMapping "); + s.readPODVector(s_allocatedVirtMemory); } void InitializeMemoryMapping() diff --git a/src/Cafe/OS/libs/coreinit/coreinit_MemoryMapping.h b/src/Cafe/OS/libs/coreinit/coreinit_MemoryMapping.h index 5988fa39..a884fa3f 100644 --- a/src/Cafe/OS/libs/coreinit/coreinit_MemoryMapping.h +++ b/src/Cafe/OS/libs/coreinit/coreinit_MemoryMapping.h @@ -1,8 +1,8 @@ namespace coreinit { - void ci_MemoryMapping_Save(MemStreamWriter& s); - void ci_MemoryMapping_Restore(MemStreamReader& s); + void MemoryMapping_Save(MemStreamWriter& s); + void MemoryMapping_Restore(MemStreamReader& s); void InitializeMemoryMapping(); } diff --git a/src/Cafe/OS/libs/coreinit/coreinit_MessageQueue.cpp b/src/Cafe/OS/libs/coreinit/coreinit_MessageQueue.cpp index dce041e1..b1789a4f 100644 --- a/src/Cafe/OS/libs/coreinit/coreinit_MessageQueue.cpp +++ b/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.writeBE(g_systemMessageQueue.GetMPTR()); - s.writeBE(_systemMessageQueueArray.GetMPTR()); + s.writeSection("coreinit_MessageQueue"); + s.writeMPTR(g_systemMessageQueue); + s.writeMPTR(_systemMessageQueueArray); } - void ci_MessageQueue_Restore(MemStreamReader& s) + void 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()); - _systemMessageQueueArray = (OSMessage*)memory_getPointerFromVirtualOffset(s.readBE()); + s.readSection("coreinit_MessageQueue"); + s.readMPTR(g_systemMessageQueue); + s.readMPTR(_systemMessageQueueArray); } void InitializeMessageQueue() diff --git a/src/Cafe/OS/libs/coreinit/coreinit_MessageQueue.h b/src/Cafe/OS/libs/coreinit/coreinit_MessageQueue.h index 97343c13..2f31022a 100644 --- a/src/Cafe/OS/libs/coreinit/coreinit_MessageQueue.h +++ b/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 ci_MessageQueue_Restore(MemStreamReader& s); + void MessageQueue_Save(MemStreamWriter& s); + void MessageQueue_Restore(MemStreamReader& s); void InitializeMessageQueue(); }; \ No newline at end of file diff --git a/src/Cafe/OS/libs/coreinit/coreinit_OverlayArena.cpp b/src/Cafe/OS/libs/coreinit/coreinit_OverlayArena.cpp index 962a9a94..85978484 100644 --- a/src/Cafe/OS/libs/coreinit/coreinit_OverlayArena.cpp +++ b/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.writeData(&g_coreinitOverlayArena, sizeof(g_coreinitOverlayArena)); + s.writeSection("coreinit_OverlayArena"); + s.writeBool(g_coreinitOverlayArena.isEnabled); } - void ci_OverlayArena_Restore(MemStreamReader& s) + void 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)); + s.readSection("coreinit_OverlayArena"); + s.readBool(g_coreinitOverlayArena.isEnabled); } void InitializeOverlayArena() diff --git a/src/Cafe/OS/libs/coreinit/coreinit_OverlayArena.h b/src/Cafe/OS/libs/coreinit/coreinit_OverlayArena.h index 52cb4dbc..70657fc9 100644 --- a/src/Cafe/OS/libs/coreinit/coreinit_OverlayArena.h +++ b/src/Cafe/OS/libs/coreinit/coreinit_OverlayArena.h @@ -1,7 +1,7 @@ namespace coreinit { - void ci_OverlayArena_Save(MemStreamWriter& s); - void ci_OverlayArena_Restore(MemStreamReader& s); + void OverlayArena_Save(MemStreamWriter& s); + void OverlayArena_Restore(MemStreamReader& s); void InitializeOverlayArena(); }; \ No newline at end of file diff --git a/src/Cafe/OS/libs/coreinit/coreinit_Synchronization.cpp b/src/Cafe/OS/libs/coreinit/coreinit_Synchronization.cpp index 4e818e24..cab6d072 100644 --- a/src/Cafe/OS/libs/coreinit/coreinit_Synchronization.cpp +++ b/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.writeBE(g_rendezvousEvent.GetMPTR()); + s.writeSection("coreinit_Synchronization"); + s.writeMPTR(g_rendezvousEvent); } - void ci_Sync_Restore(MemStreamReader& s) + void Synchronization_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()); + s.readSection("coreinit_Synchronization"); + s.readMPTR(g_rendezvousEvent); } /************* init ************/ diff --git a/src/Cafe/OS/libs/coreinit/coreinit_SysHeap.cpp b/src/Cafe/OS/libs/coreinit/coreinit_SysHeap.cpp index 41a47295..43d5bbf7 100644 --- a/src/Cafe/OS/libs/coreinit/coreinit_SysHeap.cpp +++ b/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.readData(section, 15); - cemu_assert_debug(strcmp(section, "ci_SysHeap_S") == 0); - + s.readSection("coreinit_SysHeap"); s.readData(_sysHeapHandle, sizeof(MEMHeapBase)); - _sysHeapAllocCounter = s.readBE(); - _sysHeapFreeCounter = s.readBE(); + s.readBE(_sysHeapAllocCounter); + s.readBE(_sysHeapFreeCounter); } void InitializeSysHeap() diff --git a/src/Cafe/OS/libs/coreinit/coreinit_SysHeap.h b/src/Cafe/OS/libs/coreinit/coreinit_SysHeap.h index 3001438a..23ab51e1 100644 --- a/src/Cafe/OS/libs/coreinit/coreinit_SysHeap.h +++ b/src/Cafe/OS/libs/coreinit/coreinit_SysHeap.h @@ -4,8 +4,8 @@ namespace coreinit { void InitSysHeap(); - void ci_SysHeap_Save(MemStreamWriter& s); - void ci_SysHeap_Restore(MemStreamReader& s); + void SysHeap_Save(MemStreamWriter& s); + void SysHeap_Restore(MemStreamReader& s); void InitializeSysHeap(); } \ No newline at end of file diff --git a/src/Cafe/OS/libs/coreinit/coreinit_SystemInfo.cpp b/src/Cafe/OS/libs/coreinit/coreinit_SystemInfo.cpp index 64bb4ff9..638d4093 100644 --- a/src/Cafe/OS/libs/coreinit/coreinit_SystemInfo.cpp +++ b/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.writeBE(g_system_info.GetMPTR()); + s.writeSection("coreinit_SysInfo"); + s.writeMPTR(g_system_info); } - void ci_SystemInfo_Restore(MemStreamReader& s) + void 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()); + s.readSection("coreinit_SysInfo"); + s.readMPTR(g_system_info); } void InitializeSystemInfo() diff --git a/src/Cafe/OS/libs/coreinit/coreinit_SystemInfo.h b/src/Cafe/OS/libs/coreinit/coreinit_SystemInfo.h index 49a52625..478dd4f8 100644 --- a/src/Cafe/OS/libs/coreinit/coreinit_SystemInfo.h +++ b/src/Cafe/OS/libs/coreinit/coreinit_SystemInfo.h @@ -16,8 +16,8 @@ namespace coreinit const OSSystemInfo& OSGetSystemInfo(); - void ci_SystemInfo_Save(MemStreamWriter& s); - void ci_SystemInfo_Restore(MemStreamReader& s); + void SystemInfo_Save(MemStreamWriter& s); + void SystemInfo_Restore(MemStreamReader& s); void InitializeSystemInfo(); }; diff --git a/src/Cafe/OS/libs/coreinit/coreinit_Thread.cpp b/src/Cafe/OS/libs/coreinit/coreinit_Thread.cpp index 590f625c..3237cf61 100644 --- a/src/Cafe/OS/libs/coreinit/coreinit_Thread.cpp +++ b/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(g_coreRunQueue.GetMPTR()); + s.writeBE((uint8)sSchedulerActive.load()); + 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.writeBE(s_terminatorThreads[i].threadStack.GetMPTR()); - s.writeBE(s_terminatorThreads[i].threadName.GetMPTR()); - s.writeBE(s_terminatorThreads[i].semaphoreQueuedDeallocators.GetMPTR()); + s.writeMPTR(s_terminatorThreads[i].terminatorThread); + s.writeMPTR(s_terminatorThreads[i].threadStack); + s.writeMPTR(s_terminatorThreads[i].threadName); + s.writeMPTR(s_terminatorThreads[i].semaphoreQueuedDeallocators); + s.writeMPTR(_defaultThreadName[i]); } - s.writeBE(s_defaultThreads.GetMPTR()); - s.writeBE(s_stack.GetMPTR()); + s.writeMPTR(s_defaultThreads); + s.writeMPTR(s_stack); } - void ci_Thread_Restore(MemStreamReader& s, bool recreate) + void Thread_Restore(MemStreamReader& s, bool recreate) { - char section[16] = { '\0' }; - s.readData(section,15); - cemu_assert_debug(strcmp(section, "ci_T_S") == 0); + s.readSection("coreinit_Thread"); - g_activeThreadQueue = (OSThreadQueue*)memory_getPointerFromVirtualOffset(s.readBE()); - g_coreRunQueue = (OSThreadQueue*)memory_getPointerFromVirtualOffset(s.readBE()); + sSchedulerActive.store(s.readBE()); + s.readMPTR(g_activeThreadQueue); + s.readMPTR(g_coreRunQueue); sint32 prevActiveThreadCount = s.readBE(); 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()); - s_lehmer_lcg[i] = s.readBE(); - s_terminatorThreads[i].terminatorThread = (OSThread_t*)memory_getPointerFromVirtualOffset(s.readBE()); - s_terminatorThreads[i].threadStack = (uint8*)memory_getPointerFromVirtualOffset(s.readBE()); - s_terminatorThreads[i].threadName = (char*)memory_getPointerFromVirtualOffset(s.readBE()); - s_terminatorThreads[i].semaphoreQueuedDeallocators = (OSSemaphore*)memory_getPointerFromVirtualOffset(s.readBE()); + s.readPTR(__currentCoreThread[i]); + s.readBE(s_lehmer_lcg[i]); + s.readMPTR(s_terminatorThreads[i].terminatorThread); + s.readMPTR(s_terminatorThreads[i].threadStack); + s.readMPTR(s_terminatorThreads[i].threadName); + s.readMPTR(s_terminatorThreads[i].semaphoreQueuedDeallocators); + s.readMPTR(_defaultThreadName[i]); } - s_defaultThreads = (OSThread_t*)memory_getPointerFromVirtualOffset(s.readBE()); - s_stack = (uint8*)memory_getPointerFromVirtualOffset(s.readBE()); + s.readMPTR(s_defaultThreads); + s.readMPTR(s_stack); } void SuspendActiveThreads() diff --git a/src/Cafe/OS/libs/coreinit/coreinit_Thread.h b/src/Cafe/OS/libs/coreinit/coreinit_Thread.h index 321ddb3f..de042da6 100644 --- a/src/Cafe/OS/libs/coreinit/coreinit_Thread.h +++ b/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 ci_Thread_Restore(MemStreamReader& s, bool recreate); + void Thread_Save(MemStreamWriter& s); + void 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 Synchronization_Save(MemStreamWriter& s); + void Synchronization_Restore(MemStreamReader& s); void InitializeConcurrency(); diff --git a/src/Cafe/OS/libs/dmae/dmae.cpp b/src/Cafe/OS/libs/dmae/dmae.cpp index 6b3e8d0d..1a02f61a 100644 --- a/src/Cafe/OS/libs/dmae/dmae.cpp +++ b/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() { diff --git a/src/Cafe/OS/libs/dmae/dmae.h b/src/Cafe/OS/libs/dmae/dmae.h index 26d371c9..74acef4c 100644 --- a/src/Cafe/OS/libs/dmae/dmae.h +++ b/src/Cafe/OS/libs/dmae/dmae.h @@ -1 +1,4 @@ +void dmae_save(MemStreamWriter& s); +void dmae_restore(MemStreamReader& s); + void dmae_load(); \ No newline at end of file diff --git a/src/Cafe/OS/libs/nlibcurl/nlibcurl.cpp b/src/Cafe/OS/libs/nlibcurl/nlibcurl.cpp index 9afb9f85..fafa21ed 100644 --- a/src/Cafe/OS/libs/nlibcurl/nlibcurl.cpp +++ b/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); diff --git a/src/Cafe/OS/libs/nlibcurl/nlibcurl.h b/src/Cafe/OS/libs/nlibcurl/nlibcurl.h index 5075a79c..273b5a6b 100644 --- a/src/Cafe/OS/libs/nlibcurl/nlibcurl.h +++ b/src/Cafe/OS/libs/nlibcurl/nlibcurl.h @@ -2,5 +2,8 @@ namespace nlibcurl { + void save(MemStreamWriter& s); + void restore(MemStreamReader& s); + void load(); } \ No newline at end of file diff --git a/src/Cafe/OS/libs/nn_acp/nn_acp.cpp b/src/Cafe/OS/libs/nn_acp/nn_acp.cpp index 516087a3..4d661d55 100644 --- a/src/Cafe/OS/libs/nn_acp/nn_acp.cpp +++ b/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); diff --git a/src/Cafe/OS/libs/nn_acp/nn_acp.h b/src/Cafe/OS/libs/nn_acp/nn_acp.h index cbf36c64..b4d8d4ce 100644 --- a/src/Cafe/OS/libs/nn_acp/nn_acp.h +++ b/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(); } } diff --git a/src/Cafe/OS/libs/nn_act/nn_act.cpp b/src/Cafe/OS/libs/nn_act/nn_act.cpp index fb1d4d14..f9b52871 100644 --- a/src/Cafe/OS/libs/nn_act/nn_act.cpp +++ b/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(); +} + // register account functions void nnAct_load() { diff --git a/src/Cafe/OS/libs/nn_act/nn_act.h b/src/Cafe/OS/libs/nn_act/nn_act.h index 6b0a1236..e0d0f9d6 100644 --- a/src/Cafe/OS/libs/nn_act/nn_act.h +++ b/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(); \ No newline at end of file diff --git a/src/Cafe/OS/libs/nn_aoc/nn_aoc.cpp b/src/Cafe/OS/libs/nn_aoc/nn_aoc.cpp index aa81fa58..413730c2 100644 --- a/src/Cafe/OS/libs/nn_aoc/nn_aoc.cpp +++ b/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); diff --git a/src/Cafe/OS/libs/nn_aoc/nn_aoc.h b/src/Cafe/OS/libs/nn_aoc/nn_aoc.h index 3853c075..9a08667d 100644 --- a/src/Cafe/OS/libs/nn_aoc/nn_aoc.h +++ b/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(); } } \ No newline at end of file diff --git a/src/Cafe/OS/libs/nn_boss/nn_boss.cpp b/src/Cafe/OS/libs/nn_boss/nn_boss.cpp index c2d65a5f..f71be91f 100644 --- a/src/Cafe/OS/libs/nn_boss/nn_boss.cpp +++ b/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); diff --git a/src/Cafe/OS/libs/nn_boss/nn_boss.h b/src/Cafe/OS/libs/nn_boss/nn_boss.h index f9a434a0..ca0ee066 100644 --- a/src/Cafe/OS/libs/nn_boss/nn_boss.h +++ b/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(); \ No newline at end of file diff --git a/src/Cafe/OS/libs/nn_fp/nn_fp.cpp b/src/Cafe/OS/libs/nn_fp/nn_fp.cpp index e33b6369..79e67f08 100644 --- a/src/Cafe/OS/libs/nn_fp/nn_fp.cpp +++ b/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); diff --git a/src/Cafe/OS/libs/nn_fp/nn_fp.h b/src/Cafe/OS/libs/nn_fp/nn_fp.h index daab14a0..f3529c8c 100644 --- a/src/Cafe/OS/libs/nn_fp/nn_fp.h +++ b/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(); } } \ No newline at end of file diff --git a/src/Cafe/OS/libs/nn_ndm/nn_ndm.cpp b/src/Cafe/OS/libs/nn_ndm/nn_ndm.cpp index 5a69b787..c50641c4 100644 --- a/src/Cafe/OS/libs/nn_ndm/nn_ndm.cpp +++ b/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(); i++) + _devicePoolMask.set(i); + } + void load() { osLib_addFunction("nsyshid", "HIDAddClient", export_HIDAddClient); diff --git a/src/Cafe/OS/libs/nsyshid/nsyshid.h b/src/Cafe/OS/libs/nsyshid/nsyshid.h index 051b4e7c..af901522 100644 --- a/src/Cafe/OS/libs/nsyshid/nsyshid.h +++ b/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(); } \ No newline at end of file diff --git a/src/Cafe/OS/libs/nsysnet/nsysnet.cpp b/src/Cafe/OS/libs/nsysnet/nsysnet.cpp index f39a24ea..42593938 100644 --- a/src/Cafe/OS/libs/nsysnet/nsysnet.cpp +++ b/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() { diff --git a/src/Cafe/OS/libs/nsysnet/nsysnet.h b/src/Cafe/OS/libs/nsysnet/nsysnet.h index fa2f2ca4..ce931714 100644 --- a/src/Cafe/OS/libs/nsysnet/nsysnet.h +++ b/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); diff --git a/src/Cafe/OS/libs/padscore/padscore.cpp b/src/Cafe/OS/libs/padscore/padscore.cpp index 47f3bc4f..fb9e2cf4 100644 --- a/src/Cafe/OS/libs/padscore/padscore.cpp +++ b/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 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(); + } + void load() { cafeExportRegister("padscore", WPADIsMplsAttached, LogType::InputAPI); diff --git a/src/Cafe/OS/libs/padscore/padscore.h b/src/Cafe/OS/libs/padscore/padscore.h index efb1fbca..32320061 100644 --- a/src/Cafe/OS/libs/padscore/padscore.h +++ b/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(); } diff --git a/src/Cafe/OS/libs/proc_ui/proc_ui.cpp b/src/Cafe/OS/libs/proc_ui/proc_ui.cpp index 7de8691a..4e55f051 100644 --- a/src/Cafe/OS/libs/proc_ui/proc_ui.cpp +++ b/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); diff --git a/src/Cafe/OS/libs/proc_ui/proc_ui.h b/src/Cafe/OS/libs/proc_ui/proc_ui.h index 1cd04fb1..5e23615d 100644 --- a/src/Cafe/OS/libs/proc_ui/proc_ui.h +++ b/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(); diff --git a/src/util/helpers/Serializer.cpp b/src/util/helpers/Serializer.cpp index 8e162c30..5a76337b 100644 --- a/src/util/helpers/Serializer.cpp +++ b/src/util/helpers/Serializer.cpp @@ -1,66 +1,25 @@ #include "Serializer.h" -template<> -uint8 MemStreamReader::readBE() +// readBE return + +template +T MemStreamReader::readBE() { - if (!reserveReadLength(sizeof(uint8))) + if (!reserveReadLength(sizeof(T))) return 0; - uint8 v = m_data[m_cursorPos]; - m_cursorPos += sizeof(uint8); + const uint8* p = m_data + m_cursorPos; + T v; + std::memcpy(&v, p, sizeof(v)); + v = _BE(v); + m_cursorPos += sizeof(T); return v; } -template<> -uint16 MemStreamReader::readBE() -{ - if (!reserveReadLength(sizeof(uint16))) - return 0; - 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 uint8 MemStreamReader::readBE(); +template uint16 MemStreamReader::readBE(); +template uint32 MemStreamReader::readBE(); +template uint64 MemStreamReader::readBE(); +template int MemStreamReader::readBE(); template<> std::string MemStreamReader::readBE() @@ -80,94 +39,88 @@ std::string MemStreamReader::readBE() return s; } -template<> -uint8 MemStreamReader::readLE() +// readBE void + +template +void MemStreamReader::readBE(T& v) { - return readBE(); + 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(); + 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 +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<> -uint64 MemStreamReader::readLE() +template uint8 MemStreamReader::readLE(); +template uint16 MemStreamReader::readLE(); +template uint32 MemStreamReader::readLE(); + +// readSection + +void MemStreamReader::readSection(const char* sec) { - if (!reserveReadLength(sizeof(uint64))) - return 0; - const uint8* p = m_data + m_cursorPos; - uint64 v; - std::memcpy(&v, p, sizeof(v)); - v = _LE(v); - m_cursorPos += sizeof(uint64); - return v; + std::string sec_str = std::string(sec); + cemu_assert_debug(readBE() == sec_str); } -template<> -void MemStreamWriter::writeBE(const uint64& v) +// writeBE void + +template +void MemStreamWriter::writeBE(const T& v) { - m_buffer.resize(m_buffer.size() + 8); - uint8* p = m_buffer.data() + m_buffer.size() - 8; - uint64 tmp = _BE(v); + m_buffer.resize(m_buffer.size() + sizeof(T)); + uint8* p = m_buffer.data() + m_buffer.size() - sizeof(T); + T tmp = _BE(v); std::memcpy(p, &tmp, sizeof(tmp)); } -template<> -void MemStreamWriter::writeBE(const uint32& 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(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(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(const uint8& v) -{ - m_buffer.emplace_back(v); -} - -template<> -void MemStreamWriter::writeBE(const bool& v) -{ - writeData(&v, sizeof(bool)); -} - -template<> -bool MemStreamReader::readBE() -{ - bool v{ false }; - readData(&v, sizeof(bool)); - return v; -} +template void MemStreamWriter::writeBE(const uint8& v); +template void MemStreamWriter::writeBE(const uint16& v); +template void MemStreamWriter::writeBE(const uint32& v); +template void MemStreamWriter::writeBE(const uint64& v); +template void MemStreamWriter::writeBE(const int& v); template<> void MemStreamWriter::writeBE(const std::string& v) @@ -176,21 +129,25 @@ void MemStreamWriter::writeBE(const std::string& v) writeData(v.data(), v.size()); } -template<> -void MemStreamWriter::writeLE(const uint64& v) +// writeLE void + +template +void MemStreamWriter::writeLE(const T& v) { - m_buffer.resize(m_buffer.size() + 8); - uint8* p = m_buffer.data() + m_buffer.size() - 8; - uint64 tmp = _LE(v); + m_buffer.resize(m_buffer.size() + sizeof(T)); + uint8* p = m_buffer.data() + m_buffer.size() - sizeof(T); + 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<> -void MemStreamWriter::writeLE(const uint32& v) +// writeSection + +void MemStreamWriter::writeSection(const char* sec) { - m_buffer.resize(m_buffer.size() + 4); - uint8* p = m_buffer.data() + m_buffer.size() - 4; - uint32 tmp = _LE(v); - std::memcpy(p, &tmp, sizeof(tmp)); + std::string sec_str = std::string(sec); + writeBE(sec_str); } \ No newline at end of file diff --git a/src/util/helpers/Serializer.h b/src/util/helpers/Serializer.h index 1c7bbce1..0e493254 100644 --- a/src/util/helpers/Serializer.h +++ b/src/util/helpers/Serializer.h @@ -12,6 +12,12 @@ public: template void readBE(T& v); template T readLE(); + template + void readAtomic(std::atomic& v) + { + v.store(readBE()); + } + template std::vector readPODVector() { @@ -27,6 +33,48 @@ public: return v; } + template + void readPODVector(std::vector& v) + { + uint32 numElements = readBE(); + if (!hasError()) + { + v.reserve(numElements); + v.resize(numElements); + readData(v.data(), v.size() * sizeof(T)); + } + } + + template + void readPTR(T& v) + { + v = (T)(memory_base + readBE()); + } + + template class C, typename T> + void readMPTR(C& v) + { + v = (T*)(memory_base + readBE()); + } + + template class C, typename T, size_t c, size_t a> + void readMPTR(C& v) + { + v = (T*)(memory_base + readBE()); + } + + void readBool(bool& v) + { + v = readBE(); + } + + bool readBool() + { + return readBE(); + } + + 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()) { - m_cursorPos = m_size; - m_hasError = true; + ptr = NULL; return false; } - memcpy(ptr, m_data + m_cursorPos, size); - m_cursorPos += (sint32)size; - return true; + else + { + 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 readDataNoCopy(size_t size) @@ -147,21 +203,51 @@ public: void writeData(const void* ptr, size_t size) { - m_buffer.resize(m_buffer.size() + size); - uint8* p = m_buffer.data() + m_buffer.size() - size; - memcpy(p, ptr, size); + writeBE((uint8)(ptr == NULL)); + if (ptr) + { + m_buffer.resize(m_buffer.size() + size); + uint8* p = m_buffer.data() + m_buffer.size() - size; + memcpy(p, ptr, size); + } } template void writeBE(const T& v); template void writeLE(const T& v); + + template + void writeAtomic(const std::atomic& v) + { + writeBE(v.load()); + } template void writePODVector(const std::vector& v) { + cemu_assert(std::is_trivial_v); writeBE(v.size()); writeData(v.data(), v.size() * sizeof(T)); } + template + void writePTR(const T& v) + { + writeBE((uint32)((uint8*)v - (uint8*)memory_base)); + } + + template + 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& data)