H3cJP/KytyPS5
1
0
Fork 0
mirror of https://github.com/KytyPS5/KytyPS5.git synced 2026-08-05 12:18:33 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity
Files
f3601758a7d33ed20361cf5aa93b556fda76c22e
KytyPS5/src/libs/libSaveData.cpp
T

943 lines
27 KiB
C++
Raw Blame History

#include "common/abi.h"
#include "common/assert.h"
#include "common/common.h"
#include "common/file.h"
#include "common/logging/log.h"
#include "common/stringUtils.h"
#include "common/threads.h"
#include "kernel/fileSystem.h"
#include "libs/errno.h"
#include "libs/libs.h"
#include "libs/saveDataMountSlots.h"
#include "loader/symbolDatabase.h"
#include "loader/systemContent.h"
#include <algorithm>
#include <cstring>
#include <deque>
#include <vector>
namespace Libs {
LIB_VERSION("SaveData", 1, "SaveData", 1, 1);
namespace SaveData {
// TODO(): specify dir at launcher
static constexpr char SAVE_DATA_DIR[] = "_SaveData";
static constexpr uint64_t SAVE_DATA_BLOCKS_MAX = 16384;
struct SceSaveDataDirName {
char data[32];
};
struct SceSaveDataTitleId {
char data[10];
char padding[6];
};
struct SceSaveDataFingerprint {
char data[65];
char padding[15];
};
struct SaveDataParam;
enum class SaveDataSortKey : uint32_t {
DirName = 0,
UserParam = 1,
Blocks = 2,
Mtime = 3,
FreeBlocks = 5,
};
enum class SaveDataSortOrder : uint32_t {
Ascent = 0,
Descent = 1,
};
struct SaveDataDirNameSearchCond {
int32_t user_id;
int32_t pad;
const SceSaveDataTitleId* title_id;
const SceSaveDataDirName* dir_name;
SaveDataSortKey key;
SaveDataSortOrder order;
uint8_t reserved[32];
};
struct SaveDataSearchInfo {
uint64_t blocks;
uint64_t free_blocks;
uint8_t reserved[32];
};
struct SaveDataDirNameSearchResult {
uint32_t hit_num;
int32_t pad;
SceSaveDataDirName* dir_names;
uint32_t dir_names_num;
uint32_t set_num;
SaveDataParam* params;
SaveDataSearchInfo* infos;
uint8_t reserved[12];
int32_t pad2;
};
struct SaveDataMountPoint {
char data[16];
};
struct SaveDataMount3 {
int user_id;
int pad;
const SceSaveDataDirName* dir_name;
uint64_t blocks;
uint64_t system_blocks;
uint32_t mount_mode;
int pad2;
int32_t resource;
uint8_t reserved[32];
};
struct SaveDataMountResult {
SaveDataMountPoint mount_point;
uint64_t required_blocks;
uint32_t unused;
uint32_t mount_status;
uint8_t reserved[28];
int pad;
};
struct SaveDataParam {
char title[128];
char sub_title[128];
char detail[1024];
uint32_t user_param;
int pad;
int64_t mtime;
uint8_t reserved[32];
};
struct SaveDataMountInfo {
uint64_t blocks;
uint64_t free_blocks;
uint8_t reserved[32];
};
struct SaveDataIcon {
void* buf;
size_t buf_size;
size_t data_size;
uint8_t reserved[32];
};
struct SaveDataMemoryData {
void* buf;
size_t buf_size;
int64_t offset;
uint8_t reserved[40];
};
struct SaveDataMemoryGet2 {
int32_t user_id;
uint8_t padding[4];
SaveDataMemoryData* data;
SaveDataParam* param;
SaveDataIcon* icon;
uint32_t slot_id;
uint8_t reserved[28];
};
struct SaveDataMemorySetup2 {
uint32_t option;
int32_t user_id;
size_t memory_size;
size_t icon_memory_size;
const SaveDataParam* init_param;
const SaveDataIcon* init_icon;
uint32_t slot_id;
uint8_t reserved[20];
};
struct SaveDataMemorySetupResult {
size_t existed_memory_size;
uint8_t reserved[16];
};
struct SaveDataMemorySet2 {
int32_t user_id;
uint8_t padding[4];
const SaveDataMemoryData* data;
const SaveDataParam* param;
const SaveDataIcon* icon;
uint32_t data_num;
uint32_t slot_id;
uint8_t reserved[24];
};
struct SaveDataTransferringMount {
int32_t user_id;
const SceSaveDataTitleId* title_id;
const SceSaveDataDirName* dir_name;
const void* fingerprint;
uint8_t reserved[32];
};
struct SaveDataPrepareParam {
int32_t resource;
uint32_t prepare_mode;
uint8_t reserved[32];
};
struct SaveDataCommitParam {
int32_t resource;
uint32_t commit_mode;
uint8_t reserved[32];
};
struct SaveDataDelete {
int32_t user_id;
int32_t pad;
const SceSaveDataTitleId* title_id;
const SceSaveDataDirName* dir_name;
uint32_t unused;
uint8_t reserved[32];
int32_t pad2;
};
struct SaveDataEvent {
uint32_t type;
int32_t error_code;
int32_t user_id;
uint8_t padding[4];
SceSaveDataTitleId title_id;
SceSaveDataDirName dir_name;
uint8_t reserved[40];
};
struct SaveDataBackup {
int32_t user_id;
int32_t pad;
const SceSaveDataTitleId* title_id;
const SceSaveDataDirName* dir_name;
const void* fingerprint;
uint8_t reserved[32];
};
static constexpr uint32_t SAVE_DATA_UMOUNT_MODE_BACKUP_ASYNC = (1u << 16u);
static constexpr uint32_t SAVE_DATA_COMMIT_MODE_BACKUP_ASYNC = 1u;
static constexpr uint32_t SAVE_DATA_EVENT_TYPE_UMOUNT_BACKUP_END = 1u;
static constexpr uint32_t SAVE_DATA_EVENT_TYPE_BACKUP_END = 2u;
static constexpr uint32_t SAVE_DATA_EVENT_TYPE_COMMIT_BACKUP_END = 4u;
static std::vector<uint8_t> g_save_data_memory(0x10000);
static int32_t g_next_transaction_resource = 1;
static std::deque<SaveDataEvent> g_save_data_events;
static SaveDataMountSlots g_mount_slots;
static Common::Mutex g_mount_mutex;
static std::string get_title_id() {
std::string title_id;
if (!Loader::SystemContentParamSfoGetString("TITLE_ID", &title_id) || title_id.empty()) {
title_id = "UNKNOWN";
}
return title_id;
}
static void queue_save_data_event(uint32_t type, int32_t user_id,
const SceSaveDataTitleId* title_id,
const SceSaveDataDirName* dir_name, int32_t error_code = OK) {
SaveDataEvent event = {};
event.type = type;
event.error_code = error_code;
event.user_id = user_id;
if (title_id != nullptr) {
std::memcpy(&event.title_id, title_id, sizeof(event.title_id));
}
if (dir_name != nullptr) {
std::memcpy(&event.dir_name, dir_name, sizeof(event.dir_name));
}
g_save_data_events.push_back(event);
if (g_save_data_events.size() > 20) {
g_save_data_events.pop_front();
}
}
static bool dir_name_match(const char* str, const char* pattern) {
while (*str != '\0' && *pattern != '\0') {
if (*pattern == '%') {
for (const char* s = str;; s++) {
if (dir_name_match(s, pattern + 1)) {
return true;
}
if (*s == '\0') {
break;
}
}
return false;
}
if (*pattern == '_') {
str++;
pattern++;
continue;
}
if (*pattern != *str) {
return false;
}
str++;
pattern++;
}
return *str == '\0' && *pattern == '\0';
}
static int mount_save_data(int slot, std::string_view dir_name, const std::string& directory,
uint32_t status, SaveDataMountResult* result) {
const std::string mount_point = SaveDataMountSlots::MountPoint(static_cast<size_t>(slot));
LibKernel::FileSystem::Mount(directory, mount_point);
g_mount_slots.Mount(static_cast<size_t>(slot), dir_name);
std::snprintf(result->mount_point.data, sizeof(result->mount_point.data), "%s",
mount_point.c_str());
result->required_blocks = 0;
result->mount_status = status;
return OK;
}
int KYTY_SYSV_ABI SaveDataInitialize3(const void* /*init*/) {
PRINT_NAME();
// EXIT_NOT_IMPLEMENTED(init != nullptr);
return OK;
}
int KYTY_SYSV_ABI SaveDataTerminate() {
PRINT_NAME();
Common::LockGuard lock(g_mount_mutex);
if (!g_mount_slots.Empty()) {
return SAVE_DATA_ERROR_BUSY;
}
g_save_data_events.clear();
return OK;
}
int KYTY_SYSV_ABI SaveDataCreateTransactionResource(uint32_t size) {
PRINT_NAME();
LOGF("\t size = %" PRIu32 "\n", size);
return g_next_transaction_resource++;
}
int KYTY_SYSV_ABI SaveDataDeleteTransactionResource(int32_t resource) {
PRINT_NAME();
LOGF("\t resource = %" PRId32 "\n", resource);
return OK;
}
int KYTY_SYSV_ABI SaveDataDirNameSearch(const SaveDataDirNameSearchCond* cond,
SaveDataDirNameSearchResult* result) {
PRINT_NAME();
if (cond == nullptr || result == nullptr ||
static_cast<uint32_t>(cond->key) > static_cast<uint32_t>(SaveDataSortKey::FreeBlocks) ||
static_cast<uint32_t>(cond->order) > static_cast<uint32_t>(SaveDataSortOrder::Descent)) {
return SAVE_DATA_ERROR_PARAMETER;
}
LOGF("\t user_id = %d\n"
"\t title_id = %s\n"
"\t dir_name = %s\n"
"\t key = %" PRIu32 "\n"
"\t order = %" PRIu32 "\n"
"\t dir_names_num = %" PRIu32 "\n",
cond->user_id, cond->title_id != nullptr ? cond->title_id->data : "<default>",
cond->dir_name != nullptr ? cond->dir_name->data : "<all>",
static_cast<uint32_t>(cond->key), static_cast<uint32_t>(cond->order),
result->dir_names_num);
result->hit_num = 0;
result->pad = 0;
result->set_num = 0;
std::memset(result->reserved, 0, sizeof(result->reserved));
result->pad2 = 0;
std::vector<std::string> dir_list;
std::string root =
Common::FixDirectorySlash((std::string(SAVE_DATA_DIR) + "/" + get_title_id()));
if (Common::File::IsDirectoryExisting(root)) {
for (const auto& entry: Common::File::GetDirEntries(root)) {
if (!entry.is_file && entry.name != "." && entry.name != ".." &&
!Common::StartsWith(entry.name, "sce_")) {
if (cond->dir_name == nullptr || cond->dir_name->data[0] == '\0' ||
dir_name_match(Common::ToLower(entry.name).c_str(),
Common::ToLower(std::string(cond->dir_name->data)).c_str())) {
dir_list.push_back(entry.name);
}
}
}
}
std::sort(dir_list.begin(), dir_list.end(), [](const std::string& a, const std::string& b) {
return std::strcmp(a.c_str(), b.c_str()) < 0;
});
if (cond->order == SaveDataSortOrder::Descent) {
std::vector<std::string> reversed;
for (size_t i = dir_list.size(); i > 0; i--) {
reversed.push_back(dir_list[i - 1]);
}
dir_list = reversed;
}
auto max_count =
(result->dir_names_num < dir_list.size() ? result->dir_names_num : dir_list.size());
result->hit_num = static_cast<uint32_t>(dir_list.size());
result->set_num = static_cast<uint32_t>(max_count);
for (size_t i = 0; i < max_count; i++) {
std::snprintf(result->dir_names[i].data, sizeof(result->dir_names[i].data), "%s",
dir_list[i].c_str());
if (result->params != nullptr) {
result->params[i] = {};
}
if (result->infos != nullptr) {
result->infos[i] = {};
result->infos[i].blocks = SAVE_DATA_BLOCKS_MAX;
result->infos[i].free_blocks = SAVE_DATA_BLOCKS_MAX;
}
}
return OK;
}
int KYTY_SYSV_ABI SaveDataMount3(const SaveDataMount3* mount, SaveDataMountResult* mount_result) {
PRINT_NAME();
EXIT_NOT_IMPLEMENTED(mount == nullptr);
EXIT_NOT_IMPLEMENTED(mount_result == nullptr);
EXIT_NOT_IMPLEMENTED(mount->dir_name == nullptr);
LOGF("\t user_id = %d\n"
"\t dir_name = %s\n"
"\t blocks = %" PRIu64 "\n"
"\t system_blocks = %" PRIu64 "\n"
"\t mount_mode = %" PRIu32 "\n"
"\t resource = %" PRId32 "\n",
mount->user_id, mount->dir_name->data, mount->blocks, mount->system_blocks,
mount->mount_mode, mount->resource);
*mount_result = {};
Common::LockGuard lock(g_mount_mutex);
const std::string dir_name = mount->dir_name->data;
const std::string mount_dir =
std::string(SAVE_DATA_DIR) + "/" + get_title_id() + "/" + dir_name;
const bool create = ((mount->mount_mode & 4u) != 0);
const bool create2 = ((mount->mount_mode & 32u) != 0);
const bool open = (!create && !create2 && ((mount->mount_mode & 3u) != 0));
const int slot = g_mount_slots.FindAvailable(dir_name);
if (slot == SaveDataMountSlots::BUSY) {
return SAVE_DATA_ERROR_BUSY;
}
if (slot == SaveDataMountSlots::FULL) {
return SAVE_DATA_ERROR_MOUNT_FULL;
}
if (!create && !create2 && !open) {
EXIT("unknown mount mode: %u", mount->mount_mode);
}
if (open && !Common::File::IsDirectoryExisting(mount_dir)) {
return SAVE_DATA_ERROR_NOT_FOUND;
}
if (create && Common::File::IsDirectoryExisting(mount_dir)) {
return SAVE_DATA_ERROR_EXISTS;
}
bool created = false;
if ((create || create2) && !Common::File::IsDirectoryExisting(mount_dir)) {
Common::File::CreateDirectories(mount_dir);
created = true;
EXIT_NOT_IMPLEMENTED((!Common::File::IsDirectoryExisting(mount_dir)));
}
return mount_save_data(slot, dir_name, mount_dir, created ? 1u : 0u, mount_result);
}
int KYTY_SYSV_ABI SaveDataSetupSaveDataMemory2(const SaveDataMemorySetup2* setup_param,
SaveDataMemorySetupResult* result) {
PRINT_NAME();
if (setup_param == nullptr) {
return SAVE_DATA_ERROR_PARAMETER;
}
LOGF("\t option = 0x%08" PRIx32 "\n"
"\t user_id = %" PRId32 "\n"
"\t memory_size = %" PRIu64 "\n"
"\t icon_memory_size = %" PRIu64 "\n"
"\t slot_id = %" PRIu32 "\n",
setup_param->option, setup_param->user_id, static_cast<uint64_t>(setup_param->memory_size),
static_cast<uint64_t>(setup_param->icon_memory_size), setup_param->slot_id);
if (setup_param->memory_size > g_save_data_memory.size()) {
g_save_data_memory.resize(setup_param->memory_size);
}
if (result != nullptr) {
*result = {};
result->existed_memory_size = g_save_data_memory.size();
}
return OK;
}
int KYTY_SYSV_ABI SaveDataGetSaveDataMemory2(SaveDataMemoryGet2* get_param) {
PRINT_NAME();
if (get_param == nullptr) {
return SAVE_DATA_ERROR_PARAMETER;
}
LOGF("\t user_id = %" PRId32 "\n"
"\t data = 0x%016" PRIx64 "\n"
"\t param = 0x%016" PRIx64 "\n"
"\t icon = 0x%016" PRIx64 "\n"
"\t slot_id = %" PRIu32 "\n",
get_param->user_id, reinterpret_cast<uint64_t>(get_param->data),
reinterpret_cast<uint64_t>(get_param->param), reinterpret_cast<uint64_t>(get_param->icon),
get_param->slot_id);
if (get_param->data != nullptr) {
auto* data = get_param->data;
if (data->buf == nullptr || data->offset < 0) {
return SAVE_DATA_ERROR_PARAMETER;
}
const auto offset = static_cast<size_t>(data->offset);
if (offset + data->buf_size > g_save_data_memory.size()) {
g_save_data_memory.resize(offset + data->buf_size);
}
std::memcpy(data->buf, g_save_data_memory.data() + offset, data->buf_size);
}
if (get_param->param != nullptr) {
std::memset(get_param->param, 0, sizeof(*get_param->param));
}
if (get_param->icon != nullptr) {
get_param->icon->data_size = 0;
}
return OK;
}
int KYTY_SYSV_ABI SaveDataSetSaveDataMemory2(const SaveDataMemorySet2* set_param) {
PRINT_NAME();
if (set_param == nullptr) {
return SAVE_DATA_ERROR_PARAMETER;
}
LOGF("\t user_id = %" PRId32 "\n"
"\t data = 0x%016" PRIx64 "\n"
"\t param = 0x%016" PRIx64 "\n"
"\t icon = 0x%016" PRIx64 "\n"
"\t data_num = %" PRIu32 "\n"
"\t slot_id = %" PRIu32 "\n",
set_param->user_id, reinterpret_cast<uint64_t>(set_param->data),
reinterpret_cast<uint64_t>(set_param->param), reinterpret_cast<uint64_t>(set_param->icon),
set_param->data_num, set_param->slot_id);
const uint32_t data_num = (set_param->data_num == 0 ? 1 : set_param->data_num);
if (set_param->data != nullptr) {
for (uint32_t i = 0; i < data_num; i++) {
const auto& data = set_param->data[i];
if (data.buf == nullptr || data.offset < 0) {
return SAVE_DATA_ERROR_PARAMETER;
}
const auto offset = static_cast<size_t>(data.offset);
if (offset + data.buf_size > g_save_data_memory.size()) {
g_save_data_memory.resize(offset + data.buf_size);
}
std::memcpy(g_save_data_memory.data() + offset, data.buf, data.buf_size);
}
}
return OK;
}
int KYTY_SYSV_ABI SaveDataTransferringMount(const SaveDataTransferringMount* mount,
SaveDataMountResult* mount_result) {
PRINT_NAME();
if (mount == nullptr || mount_result == nullptr || mount->dir_name == nullptr) {
return SAVE_DATA_ERROR_PARAMETER;
}
LOGF("\t user_id = %" PRId32 "\n"
"\t title_id = %s\n"
"\t dir_name = %s\n",
mount->user_id, mount->title_id != nullptr ? mount->title_id->data : "<null>",
mount->dir_name->data);
*mount_result = {};
Common::LockGuard lock(g_mount_mutex);
const std::string dir_name = mount->dir_name->data;
const std::string mount_dir =
std::string(SAVE_DATA_DIR) + "/" + get_title_id() + "/" + dir_name;
const int slot = g_mount_slots.FindAvailable(dir_name);
if (slot == SaveDataMountSlots::BUSY) {
return SAVE_DATA_ERROR_BUSY;
}
if (slot == SaveDataMountSlots::FULL) {
return SAVE_DATA_ERROR_MOUNT_FULL;
}
if (!Common::File::IsDirectoryExisting(mount_dir)) {
Common::File::CreateDirectories(mount_dir);
}
return mount_save_data(slot, dir_name, mount_dir, 1, mount_result);
}
int KYTY_SYSV_ABI SaveDataUmount2(uint32_t mode, const SaveDataMountPoint* mount_point) {
PRINT_NAME();
if (mount_point == nullptr) {
return SAVE_DATA_ERROR_PARAMETER;
}
LOGF("\t mode = %" PRIu32 "\n"
"\t mount_point = %s\n",
mode, mount_point->data);
Common::LockGuard lock(g_mount_mutex);
const std::string point = mount_point->data;
const int slot = g_mount_slots.Find(point);
if (slot == SaveDataMountSlots::FULL) {
return SAVE_DATA_ERROR_NOT_FOUND;
}
if ((mode & SAVE_DATA_UMOUNT_MODE_BACKUP_ASYNC) != 0) {
queue_save_data_event(SAVE_DATA_EVENT_TYPE_UMOUNT_BACKUP_END, 0, nullptr, nullptr);
}
LibKernel::FileSystem::Umount(point);
g_mount_slots.Release(static_cast<size_t>(slot));
return OK;
}
int KYTY_SYSV_ABI SaveDataPrepare(const SaveDataMountPoint* mount_point,
const SaveDataPrepareParam* param) {
PRINT_NAME();
if (mount_point == nullptr || param == nullptr) {
return SAVE_DATA_ERROR_PARAMETER;
}
LOGF("\t mount_point = %s\n"
"\t resource = %" PRId32 "\n"
"\t prepare_mode = %" PRIu32 "\n",
mount_point->data, param->resource, param->prepare_mode);
return OK;
}
int KYTY_SYSV_ABI SaveDataCommit(const SaveDataCommitParam* param) {
PRINT_NAME();
if (param == nullptr) {
return SAVE_DATA_ERROR_PARAMETER;
}
LOGF("\t resource = %" PRId32 "\n"
"\t commit_mode = %" PRIu32 "\n",
param->resource, param->commit_mode);
if ((param->commit_mode & SAVE_DATA_COMMIT_MODE_BACKUP_ASYNC) != 0) {
queue_save_data_event(SAVE_DATA_EVENT_TYPE_COMMIT_BACKUP_END, 0, nullptr, nullptr);
}
return OK;
}
int KYTY_SYSV_ABI SaveDataDelete(const SaveDataDelete* del) {
PRINT_NAME();
if (del == nullptr || del->dir_name == nullptr) {
return SAVE_DATA_ERROR_PARAMETER;
}
LOGF("\t user_id = %" PRId32 "\n"
"\t title_id = %s\n"
"\t dir_name = %s\n",
del->user_id, del->title_id != nullptr ? del->title_id->data : "<default>",
del->dir_name->data);
std::string dir =
std::string(SAVE_DATA_DIR) + "/" + get_title_id() + "/" + std::string(del->dir_name->data);
if (Common::File::IsDirectoryExisting(dir)) {
Common::File::DeleteDirectory(dir);
}
return OK;
}
int KYTY_SYSV_ABI SaveDataGetParam(const SaveDataMountPoint* mount_point, uint32_t param_type,
void* param_buf, size_t param_buf_size, size_t* got_size) {
PRINT_NAME();
if (mount_point == nullptr || param_buf == nullptr) {
return SAVE_DATA_ERROR_PARAMETER;
}
LOGF("\t mount_point = %s\n"
"\t param_type = %u\n"
"\t param_buf_size = %" PRIu64 "\n",
mount_point->data, param_type, param_buf_size);
if (param_type == 0) {
if (param_buf_size < sizeof(SaveDataParam)) {
return SAVE_DATA_ERROR_PARAMETER;
}
std::memset(param_buf, 0, sizeof(SaveDataParam));
if (got_size != nullptr) {
*got_size = sizeof(SaveDataParam);
}
return OK;
}
std::memset(param_buf, 0, param_buf_size);
if (got_size != nullptr) {
*got_size = param_buf_size;
}
return OK;
}
int KYTY_SYSV_ABI SaveDataLoadIcon(const SaveDataMountPoint* mount_point, SaveDataIcon* icon) {
PRINT_NAME();
if (mount_point == nullptr || icon == nullptr) {
return SAVE_DATA_ERROR_PARAMETER;
}
LOGF("\t mount_point = %s\n"
"\t buf = %016" PRIx64 "\n"
"\t buf_size = %" PRIu64 "\n",
mount_point->data, reinterpret_cast<uint64_t>(icon->buf), icon->buf_size);
icon->data_size = 0;
return OK;
}
int KYTY_SYSV_ABI SaveDataSaveIconByPath(const SaveDataMountPoint* mount_point, const char* path) {
PRINT_NAME();
if (mount_point == nullptr || path == nullptr) {
return SAVE_DATA_ERROR_PARAMETER;
}
LOGF("\t mount_point = %s\n"
"\t path = %s\n",
mount_point->data, path);
return OK;
}
int KYTY_SYSV_ABI SaveDataSyncSaveDataMemory(const void* sync_param) {
PRINT_NAME();
LOGF("\t sync_param = 0x%016" PRIx64 "\n", reinterpret_cast<uint64_t>(sync_param));
return OK;
}
int KYTY_SYSV_ABI SaveDataGetEventResult(const void* event_param, SaveDataEvent* event) {
PRINT_NAME();
LOGF("\t event_param = 0x%016" PRIx64 "\n"
"\t event = 0x%016" PRIx64 "\n",
reinterpret_cast<uint64_t>(event_param), reinterpret_cast<uint64_t>(event));
if (event == nullptr) {
return SAVE_DATA_ERROR_PARAMETER;
}
if (g_save_data_events.empty()) {
return SAVE_DATA_ERROR_NOT_FOUND;
}
*event = g_save_data_events.front();
g_save_data_events.pop_front();
LOGF("\t type = %" PRIu32 "\n"
"\t error_code = %" PRId32 "\n"
"\t user_id = %" PRId32 "\n"
"\t title_id = %.10s\n"
"\t dir_name = %.32s\n",
event->type, event->error_code, event->user_id, event->title_id.data,
event->dir_name.data);
return OK;
}
int KYTY_SYSV_ABI SaveDataBackup(const SaveDataBackup* backup) {
PRINT_NAME();
LOGF("\t backup = 0x%016" PRIx64 "\n", reinterpret_cast<uint64_t>(backup));
if (backup == nullptr || backup->dir_name == nullptr) {
return SAVE_DATA_ERROR_PARAMETER;
}
LOGF("\t user_id = %" PRId32 "\n"
"\t title_id = %.10s\n"
"\t dir_name = %.32s\n",
backup->user_id, backup->title_id != nullptr ? backup->title_id->data : "<default>",
backup->dir_name->data);
queue_save_data_event(SAVE_DATA_EVENT_TYPE_BACKUP_END, backup->user_id, backup->title_id,
backup->dir_name);
return OK;
}
int KYTY_SYSV_ABI SaveDataSetParam(const SaveDataMountPoint* mount_point, uint32_t param_type,
const void* param_buf, size_t param_buf_size) {
PRINT_NAME();
EXIT_NOT_IMPLEMENTED(mount_point == nullptr);
LOGF("\t mount_point = %s\n"
"\t param_type = %u\n"
"\t param_buf_size = %" PRIu64 "\n",
mount_point->data, param_type, param_buf_size);
if (param_type == 0) {
const auto* p = static_cast<const SaveDataParam*>(param_buf);
LOGF("\t title = %s\n"
"\t sub_title = %s\n"
"\t detail = %s\n"
"\t user_param = %u\n",
p->title, p->sub_title, p->detail, p->user_param);
} else {
LOGF("\t unsupported param_type, accepting as no-op\n");
}
return OK;
}
int KYTY_SYSV_ABI SaveDataGetMountInfo(const SaveDataMountPoint* mount_point,
SaveDataMountInfo* info) {
PRINT_NAME();
EXIT_NOT_IMPLEMENTED(mount_point == nullptr);
EXIT_NOT_IMPLEMENTED(info == nullptr);
*info = {};
info->blocks = SAVE_DATA_BLOCKS_MAX;
info->free_blocks = SAVE_DATA_BLOCKS_MAX;
return OK;
}
int KYTY_SYSV_ABI SaveDataSaveIcon(const SaveDataMountPoint* mount_point,
const SaveDataIcon* icon) {
EXIT_NOT_IMPLEMENTED(mount_point == nullptr);
EXIT_NOT_IMPLEMENTED(icon == nullptr);
LOGF("\t buf = %016" PRIx64 "\n"
"\t buf_size = %" PRIu64 "\n"
"\t data_size = %" PRIu64 "\n",
reinterpret_cast<uint64_t>(icon->buf), icon->buf_size, icon->data_size);
return OK;
}
} // namespace SaveData
namespace LibSaveDataNative {
LIB_VERSION("SaveData_native", 1, "SaveData_native", 1, 1);
LIB_DEFINE(InitSaveDataNative_1) {
LIB_FUNC("TywrFKCoLGY", ::Libs::SaveData::SaveDataInitialize3);
LIB_FUNC("dyIhnXq-0SM", ::Libs::SaveData::SaveDataDirNameSearch);
LIB_FUNC("PHnuI4LhuRk", ::Libs::SaveData::SaveDataDirNameSearch);
LIB_FUNC("ZP4e7rlzOUk", ::Libs::SaveData::SaveDataMount3);
LIB_FUNC("gjRZNnw0JPE", ::Libs::SaveData::SaveDataCreateTransactionResource);
LIB_FUNC("lJUQuaKqoKY", ::Libs::SaveData::SaveDataDeleteTransactionResource);
LIB_FUNC("sDCBrmc61XU", ::Libs::SaveData::SaveDataPrepare);
LIB_FUNC("ie7qhZ4X0Cc", ::Libs::SaveData::SaveDataCommit);
LIB_FUNC("oQySEUfgXRA", ::Libs::SaveData::SaveDataSetupSaveDataMemory2);
LIB_FUNC("QwOO7vegnV8", ::Libs::SaveData::SaveDataGetSaveDataMemory2);
LIB_FUNC("cduy9v4YmT4", ::Libs::SaveData::SaveDataSetSaveDataMemory2);
LIB_FUNC("wiT9jeC7xPw", ::Libs::SaveData::SaveDataSyncSaveDataMemory);
LIB_FUNC("j8xKtiFj0SY", ::Libs::SaveData::SaveDataGetEventResult);
LIB_FUNC("WAzWTZm1H+I", ::Libs::SaveData::SaveDataTransferringMount);
LIB_FUNC("RjMlsR8EXrw", ::Libs::SaveData::SaveDataTransferringMount);
LIB_FUNC("z1JA8-iJt3k", ::Libs::SaveData::SaveDataBackup);
LIB_FUNC("uW4vfTwMQVo", ::Libs::SaveData::SaveDataUmount2);
LIB_FUNC("S1GkePI17zQ", ::Libs::SaveData::SaveDataDelete);
LIB_FUNC("85zul--eGXs", ::Libs::SaveData::SaveDataSetParam);
LIB_FUNC("XgvSuIdnMlw", ::Libs::SaveData::SaveDataGetParam);
LIB_FUNC("65VH0Qaaz6s", ::Libs::SaveData::SaveDataGetMountInfo);
LIB_FUNC("c88Yy54Mx0w", ::Libs::SaveData::SaveDataSaveIcon);
LIB_FUNC("Z7z6HXWORJY", ::Libs::SaveData::SaveDataSaveIconByPath);
LIB_FUNC("cGjO3wM3V28", ::Libs::SaveData::SaveDataLoadIcon);
LIB_FUNC("X4MYzukPc3g", ::Libs::SaveData::SaveDataDirNameSearch);
LIB_FUNC("yKDy8S5yLA0", ::Libs::SaveData::SaveDataTerminate);
}
} // namespace LibSaveDataNative
LIB_DEFINE(InitSaveData_1) {
LIB_FUNC("TywrFKCoLGY", SaveData::SaveDataInitialize3);
LIB_FUNC("dyIhnXq-0SM", SaveData::SaveDataDirNameSearch);
LIB_FUNC("ZP4e7rlzOUk", SaveData::SaveDataMount3);
LIB_FUNC("gjRZNnw0JPE", SaveData::SaveDataCreateTransactionResource);
LIB_FUNC("lJUQuaKqoKY", SaveData::SaveDataDeleteTransactionResource);
LIB_FUNC("sDCBrmc61XU", SaveData::SaveDataPrepare);
LIB_FUNC("ie7qhZ4X0Cc", SaveData::SaveDataCommit);
LIB_FUNC("oQySEUfgXRA", SaveData::SaveDataSetupSaveDataMemory2);
LIB_FUNC("QwOO7vegnV8", SaveData::SaveDataGetSaveDataMemory2);
LIB_FUNC("cduy9v4YmT4", SaveData::SaveDataSetSaveDataMemory2);
LIB_FUNC("wiT9jeC7xPw", SaveData::SaveDataSyncSaveDataMemory);
LIB_FUNC("j8xKtiFj0SY", SaveData::SaveDataGetEventResult);
LIB_FUNC("WAzWTZm1H+I", SaveData::SaveDataTransferringMount);
LIB_FUNC("RjMlsR8EXrw", SaveData::SaveDataTransferringMount);
LIB_FUNC("z1JA8-iJt3k", SaveData::SaveDataBackup);
LIB_FUNC("uW4vfTwMQVo", SaveData::SaveDataUmount2);
LIB_FUNC("S1GkePI17zQ", SaveData::SaveDataDelete);
LIB_FUNC("85zul--eGXs", SaveData::SaveDataSetParam);
LIB_FUNC("XgvSuIdnMlw", SaveData::SaveDataGetParam);
LIB_FUNC("65VH0Qaaz6s", SaveData::SaveDataGetMountInfo);
LIB_FUNC("c88Yy54Mx0w", SaveData::SaveDataSaveIcon);
LIB_FUNC("Z7z6HXWORJY", SaveData::SaveDataSaveIconByPath);
LIB_FUNC("cGjO3wM3V28", SaveData::SaveDataLoadIcon);
LIB_FUNC("X4MYzukPc3g", SaveData::SaveDataDirNameSearch);
LIB_FUNC("yKDy8S5yLA0", SaveData::SaveDataTerminate);
LibSaveDataNative::InitSaveDataNative_1(s);
}
} // namespace Libs
Reference in New Issue View Git Blame Copy Permalink