shifathosn
/
AnyPS5
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #1680 from emirplus/fix/savedata-memory-metadata 

fix(savedata): recover from metadata setup failure
This commit is contained in:
Dean 2026-10-12 16:08:53 +13:00 committed by GitHub
parent 01e5f3b8a8 6a7cce415a
commit 4dfa8506b3
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
3 changed files with 192 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
core/libs/prx/libSceSaveData.native/Export.cpp
View File

@ -647,22 +647,30 @@ static int setupSaveDataMemory2(const SaveDataMemorySetup2* setup_param, SaveDat
if (!have) {
existed = 0;
}
const bool needParam = (setup_param->init_param != nullptr && (setup_param->option & 1u) != 0);
const std::string paramPath = mem_path(setup_param->user_id, setup_param->slot_id, "param");
std::size_t paramSize = 0;
const bool haveParam = file_size_of(paramPath, &paramSize);
// First run: create a zero-filled blob and report existed size 0 so the title treats it as a new save.
if (!have || existed < setup_param->memory_size) {
if (!have || existed < setup_param->memory_size || (needParam && !haveParam)) {
std::error_code ec;
std::filesystem::create_directories(std::filesystem::path(path).parent_path(), ec);
std::vector<char> data;
if (have && !read_file_all(path, data)) {
return SAVE_DATA_ERROR_INTERNAL;
}
data.resize(setup_param->memory_size, 0);
if (!write_file_replace(path, data)) {
return SAVE_DATA_ERROR_INTERNAL;
}
if (setup_param->init_param != nullptr && (setup_param->option & 1u) != 0) {
if (needParam) {
std::vector<char> pd(sizeof(SaveDataParam));
std::memcpy(pd.data(), setup_param->init_param, sizeof(SaveDataParam));
write_file_replace(mem_path(setup_param->user_id, setup_param->slot_id, "param"), pd);
if (!write_file_replace(paramPath, pd)) {
return SAVE_DATA_ERROR_INTERNAL;
}
}
if (!have || existed < setup_param->memory_size) {
std::vector<char> data;
if (have && !read_file_all(path, data)) {
return SAVE_DATA_ERROR_INTERNAL;
}
data.resize(setup_param->memory_size, 0);
if (!write_file_replace(path, data)) {
return SAVE_DATA_ERROR_INTERNAL;
}
}
}
if (result != nullptr) {

4
core/libs/tests/SaveDataMemoryGrowth.cpp
View File

@ -82,10 +82,10 @@ int main(int argc, char**) {
std::fprintf(stderr, "Read denial unavailable for this user\n");
exitCode = 77;
} else {
Require(Read(path) == original);
Require(status == static_cast<int>(0x809F000Bu));
Require(Read(path) == original);
Require(result.existed_memory_size == 123);
Require(!std::filesystem::exists("_sd_mem/u7531/slot0.param"));
Require(std::filesystem::is_regular_file("_sd_mem/u7531/slot0.param"));
Require(!std::filesystem::exists(path.string() + ".tmp"));
}
} else {

171
core/libs/tests/SaveDataMemoryMetadata.cpp
View File

@ -19,6 +19,7 @@ extern "C" {
int APS5_VABI sceSaveDataInitialize3(const void*);
int APS5_VABI sceSaveDataTerminate();
int APS5_VABI sceSaveDataSetSaveDataMemory2(const SaveDataMemorySet2*);
int APS5_VABI sceSaveDataSetupSaveDataMemory2(const SaveDataMemorySetup2*, SaveDataMemorySetupResult*);
}
static void Check(bool value, int line) {
@ -115,6 +116,176 @@ int main() {
Require(sceSaveDataSetSaveDataMemory2(&set) == 0);
std::copy(first.begin(), first.end(), memoryExpected.begin() + 4);
Require(Read(memoryPath) == memoryExpected);
const auto setupParamPath = std::filesystem::path("_sd_mem/u42/slot0.param");
const auto setupBinPath = std::filesystem::path("_sd_mem/u42/slot0.bin");
const auto setupParamTemp = setupParamPath.string() + ".tmp";
Require(std::filesystem::create_directories(setupParamPath.parent_path()));
Require(std::filesystem::create_directory(setupParamTemp));
SaveDataParam setupParam{};
setupParam.user_param = 100;
SaveDataMemorySetup2 setup2{};
setup2.user_id = 42;
setup2.slot_id = 0;
setup2.memory_size = 128;
setup2.option = 1;
setup2.init_param = &setupParam;
SaveDataMemorySetupResult setupResult{};
setupResult.existed_memory_size = 555;
Require(sceSaveDataSetupSaveDataMemory2(&setup2, &setupResult) == static_cast<int>(0x809F000Bu));
Require(setupResult.existed_memory_size == 555);
Require(!std::filesystem::exists(setupBinPath));
Require(!std::filesystem::exists(setupParamPath));
Require(!std::filesystem::exists(setupParamTemp));
Require(sceSaveDataSetupSaveDataMemory2(&setup2, &setupResult) == 0);
Require(setupResult.existed_memory_size == 0);
Require(Read(setupBinPath) == std::vector<char>(128, 0));
const auto* setupBytes = reinterpret_cast<const char*>(&setupParam);
Require(Read(setupParamPath) == std::vector<char>(setupBytes, setupBytes + sizeof(setupParam)));
std::vector<char> seededBin(128);
for (std::size_t i = 0; i < seededBin.size(); ++i) {
seededBin[i] = static_cast<char>(static_cast<unsigned char>(i * 3 + 7));
}
{
std::ofstream seededFile(setupBinPath, std::ios::binary);
seededFile.write(seededBin.data(), static_cast<std::streamsize>(seededBin.size()));
Require(static_cast<bool>(seededFile));
}
const auto growthParamTemp = setupParamPath.string() + ".tmp";
Require(std::filesystem::create_directory(growthParamTemp));
SaveDataParam previousParam = setupParam;
setupParam.user_param = 200;
setup2.memory_size = 256;
setupResult.existed_memory_size = 999;
Require(sceSaveDataSetupSaveDataMemory2(&setup2, &setupResult) == static_cast<int>(0x809F000Bu));
Require(setupResult.existed_memory_size == 999);
Require(Read(setupBinPath) == seededBin);
const auto* previousBytes = reinterpret_cast<const char*>(&previousParam);
Require(Read(setupParamPath) == std::vector<char>(previousBytes, previousBytes + sizeof(previousParam)));
Require(!std::filesystem::exists(growthParamTemp));
Require(sceSaveDataSetupSaveDataMemory2(&setup2, &setupResult) == 0);
Require(setupResult.existed_memory_size == 128);
std::vector<char> expectedGrownBin = seededBin;
expectedGrownBin.resize(256, 0);
Require(Read(setupBinPath) == expectedGrownBin);
const auto* updatedBytes = reinterpret_cast<const char*>(&setupParam);
Require(Read(setupParamPath) == std::vector<char>(updatedBytes, updatedBytes + sizeof(setupParam)));
const auto growthBinTemp = setupBinPath.string() + ".tmp";
Require(std::filesystem::create_directory(growthBinTemp));
setupParam.user_param = 300;
setup2.memory_size = 512;
setupResult.existed_memory_size = 888;
Require(sceSaveDataSetupSaveDataMemory2(&setup2, &setupResult) == static_cast<int>(0x809F000Bu));
Require(setupResult.existed_memory_size == 888);
Require(Read(setupBinPath) == expectedGrownBin);
const auto* param300Bytes = reinterpret_cast<const char*>(&setupParam);
Require(Read(setupParamPath) == std::vector<char>(param300Bytes, param300Bytes + sizeof(setupParam)));
Require(!std::filesystem::exists(growthBinTemp));
Require(sceSaveDataSetupSaveDataMemory2(&setup2, &setupResult) == 0);
Require(setupResult.existed_memory_size == 256);
std::vector<char> expectedBlob512 = expectedGrownBin;
expectedBlob512.resize(512, 0);
Require(Read(setupBinPath) == expectedBlob512);
Require(Read(setupParamPath) == std::vector<char>(param300Bytes, param300Bytes + sizeof(setupParam)));
const auto freshFailBinPath = std::filesystem::path("_sd_mem/u55/slot0.bin");
const auto freshFailParamPath = std::filesystem::path("_sd_mem/u55/slot0.param");
Require(std::filesystem::create_directories(freshFailBinPath.parent_path()));
const auto freshFailBinTemp = freshFailBinPath.string() + ".tmp";
Require(std::filesystem::create_directory(freshFailBinTemp));
SaveDataParam freshFailParam{};
freshFailParam.user_param = 55;
SaveDataMemorySetup2 freshFailSetup{};
freshFailSetup.user_id = 55;
freshFailSetup.slot_id = 0;
freshFailSetup.memory_size = 64;
freshFailSetup.option = 1;
freshFailSetup.init_param = &freshFailParam;
SaveDataMemorySetupResult freshFailResult{};
freshFailResult.existed_memory_size = 777;
Require(sceSaveDataSetupSaveDataMemory2(&freshFailSetup, &freshFailResult) == static_cast<int>(0x809F000Bu));
Require(freshFailResult.existed_memory_size == 777);
Require(!std::filesystem::exists(freshFailBinPath));
const auto* freshFailBytes = reinterpret_cast<const char*>(&freshFailParam);
Require(Read(freshFailParamPath) == std::vector<char>(freshFailBytes, freshFailBytes + sizeof(freshFailParam)));
Require(!std::filesystem::exists(freshFailBinTemp));
Require(sceSaveDataSetupSaveDataMemory2(&freshFailSetup, &freshFailResult) == 0);
Require(freshFailResult.existed_memory_size == 0);
Require(Read(freshFailBinPath) == std::vector<char>(64, 0));
Require(Read(freshFailParamPath) == std::vector<char>(freshFailBytes, freshFailBytes + sizeof(freshFailParam)));
SaveDataParam noParam{};
noParam.user_param = 5;
SaveDataMemorySetup2 noParamSetup{};
SaveDataMemorySetupResult noParamResult{};
noParamSetup.user_id = 56;
noParamSetup.slot_id = 0;
noParamSetup.memory_size = 16;
noParamSetup.option = 1;
noParamSetup.init_param = nullptr;
Require(sceSaveDataSetupSaveDataMemory2(&noParamSetup, &noParamResult) == 0);
Require(Read("_sd_mem/u56/slot0.bin") == std::vector<char>(16, 0));
Require(!std::filesystem::exists("_sd_mem/u56/slot0.param"));
noParamSetup.user_id = 57;
noParamSetup.option = 0;
noParamSetup.init_param = &noParam;
Require(sceSaveDataSetupSaveDataMemory2(&noParamSetup, &noParamResult) == 0);
Require(Read("_sd_mem/u57/slot0.bin") == std::vector<char>(16, 0));
Require(!std::filesystem::exists("_sd_mem/u57/slot0.param"));
SaveDataParam userA{};
userA.user_param = 1;
SaveDataParam userB{};
userB.user_param = 2;
SaveDataMemorySetup2 isoSetup{};
SaveDataMemorySetupResult isoResult{};
isoSetup.user_id = 60;
isoSetup.slot_id = 0;
isoSetup.memory_size = 8;
isoSetup.option = 1;
isoSetup.init_param = &userA;
Require(sceSaveDataSetupSaveDataMemory2(&isoSetup, &isoResult) == 0);
isoSetup.slot_id = 1;
isoSetup.init_param = &userB;
Require(sceSaveDataSetupSaveDataMemory2(&isoSetup, &isoResult) == 0);
const auto* userABytes = reinterpret_cast<const char*>(&userA);
const auto* userBBytes = reinterpret_cast<const char*>(&userB);
Require(Read("_sd_mem/u60/slot0.param") == std::vector<char>(userABytes, userABytes + sizeof(userA)));
Require(Read("_sd_mem/u60/slot1.param") == std::vector<char>(userBBytes, userBBytes + sizeof(userB)));
isoSetup.user_id = 61;
isoSetup.slot_id = 0;
Require(sceSaveDataSetupSaveDataMemory2(&isoSetup, &isoResult) == 0);
Require(Read("_sd_mem/u60/slot0.param") == std::vector<char>(userABytes, userABytes + sizeof(userA)));
Require(Read("_sd_mem/u61/slot0.param") == std::vector<char>(userBBytes, userBBytes + sizeof(userB)));
const auto orphanParamPath = std::filesystem::path("_sd_mem/u99/slot0.param");
const auto orphanBinPath = std::filesystem::path("_sd_mem/u99/slot0.bin");
Require(std::filesystem::create_directories(orphanBinPath.parent_path()));
const std::vector<char> orphanBin(64, 'k');
{
std::ofstream orphanFile(orphanBinPath, std::ios::binary);
orphanFile.write(orphanBin.data(), static_cast<std::streamsize>(orphanBin.size()));
Require(static_cast<bool>(orphanFile));
}
SaveDataParam orphanParam{};
orphanParam.user_param = 42;
SaveDataMemorySetup2 orphanSetup{};
orphanSetup.user_id = 99;
orphanSetup.slot_id = 0;
orphanSetup.memory_size = 64;
orphanSetup.option = 1;
orphanSetup.init_param = &orphanParam;
SaveDataMemorySetupResult orphanResult{};
orphanResult.existed_memory_size = 333;
Require(sceSaveDataSetupSaveDataMemory2(&orphanSetup, &orphanResult) == 0);
Require(orphanResult.existed_memory_size == 64);
Require(Read(orphanBinPath) == orphanBin);
const auto* orphanBytes = reinterpret_cast<const char*>(&orphanParam);
Require(Read(orphanParamPath) == std::vector<char>(orphanBytes, orphanBytes + sizeof(orphanParam)));
Require(sceSaveDataTerminate() == 0);
Require(Read(setupBinPath) == expectedBlob512);
Require(Read(setupParamPath) == std::vector<char>(param300Bytes, param300Bytes + sizeof(setupParam)));
Require(sceSaveDataInitialize3(nullptr) == 0);
setupResult.existed_memory_size = 111;
Require(sceSaveDataSetupSaveDataMemory2(&setup2, &setupResult) == 0);
Require(setupResult.existed_memory_size == 512);
Require(Read(setupBinPath) == expectedBlob512);
Require(Read(setupParamPath) == std::vector<char>(param300Bytes, param300Bytes + sizeof(setupParam)));
Require(sceSaveDataTerminate() == 0);
std::filesystem::current_path(previous);
std::filesystem::remove_all(root);