Initial UserSaveData impl

CMakeLists.txt

@@ -147,7 +147,7 @@ set(PICA_SOURCE_FILES src/core/PICA/gpu.cpp src/core/PICA/regs.cpp src/core/PICA
 set(LOADER_SOURCE_FILES src/core/loader/elf.cpp src/core/loader/ncsd.cpp src/core/loader/ncch.cpp src/core/loader/lz77.cpp)
 set(FS_SOURCE_FILES src/core/fs/archive_self_ncch.cpp src/core/fs/archive_save_data.cpp src/core/fs/archive_sdmc.cpp
                     src/core/fs/archive_ext_save_data.cpp src/core/fs/archive_ncch.cpp src/core/fs/romfs.cpp
-                    src/core/fs/ivfc.cpp
+                    src/core/fs/ivfc.cpp src/core/fs/archive_user_save_data.cpp
 )
 
 set(APPLET_SOURCE_FILES src/core/applets/applet.cpp src/core/applets/mii_selector.cpp src/core/applets/software_keyboard.cpp src/core/applets/applet_manager.cpp)
@@ -180,7 +180,7 @@ set(HEADER_FILES include/emulator.hpp include/helpers.hpp include/termcolor.hpp
                  include/action_replay.hpp include/renderer_sw/renderer_sw.hpp include/compiler_builtins.hpp
                  include/fs/romfs.hpp include/fs/ivfc.hpp include/discord_rpc.hpp include/services/http.hpp include/result/result_cfg.hpp
                  include/applets/applet.hpp include/applets/mii_selector.hpp include/math_util.hpp include/services/soc.hpp 
-                 include/services/news_u.hpp include/applets/software_keyboard.hpp include/applets/applet_manager.hpp
+                 include/services/news_u.hpp include/applets/software_keyboard.hpp include/applets/applet_manager.hpp include/fs/archive_user_save_data.hpp
 )
 
 cmrc_add_resource_library(

include/fs/archive_base.hpp

@@ -25,17 +25,22 @@ namespace PathType {
 }
 
 namespace ArchiveID {
-    enum : u32 {
+	enum : u32 {
-        SelfNCCH = 3,
+		SelfNCCH = 3,
-        SaveData = 4,
+		SaveData = 4,
-        ExtSaveData = 6,
+		ExtSaveData = 6,
-        SharedExtSaveData = 7,
+		SharedExtSaveData = 7,
-        SystemSaveData = 8,
+		SystemSaveData = 8,
-        SDMC = 9,
+		SDMC = 9,
-        SDMCWriteOnly = 0xA,
+		SDMCWriteOnly = 0xA,
 
-        SavedataAndNcch = 0x2345678A
+		SavedataAndNcch = 0x2345678A,
-    };
+		// 3DBrew: This is the same as the regular SaveData archive, except with this the savedata ID and mediatype is loaded from the input archive
+		// lowpath.
+		UserSaveData1 = 0x567890B2,
+		// 3DBrew: Similar to 0x567890B2 but can only access Accessible Save specified in exheader?
+		UserSaveData2 = 0x567890B4,
+	};
 
     static std::string toString(u32 id) {
         switch (id) {

include/fs/archive_user_save_data.hpp

@@ -0,0 +1,31 @@
+#pragma once
+#include "archive_base.hpp"
+
+class UserSaveDataArchive : public ArchiveBase {
+	u32 archiveID;
+  public:
+	UserSaveDataArchive(Memory& mem, u32 archiveID) : ArchiveBase(mem), archiveID(archiveID) {}
+
+	u64 getFreeBytes() override { return 32_MB; }
+	std::string name() override { return "UserSaveData"; }
+
+	HorizonResult createDirectory(const FSPath& path) override;
+	HorizonResult createFile(const FSPath& path, u64 size) override;
+	HorizonResult deleteFile(const FSPath& path) override;
+
+	Rust::Result<ArchiveBase*, HorizonResult> openArchive(const FSPath& path) override;
+	Rust::Result<DirectorySession, HorizonResult> openDirectory(const FSPath& path) override;
+	FileDescriptor openFile(const FSPath& path, const FilePerms& perms) override;
+	std::optional<u32> readFile(FileSession* file, u64 offset, u32 size, u32 dataPointer) override;
+
+	void format(const FSPath& path, const FormatInfo& info) override;
+	Rust::Result<FormatInfo, HorizonResult> getFormatInfo(const FSPath& path) override;
+
+	std::filesystem::path getFormatInfoPath() { return IOFile::getAppData() / "FormatInfo" / "SaveData.format"; }
+
+	// Returns whether the cart has save data or not
+	bool cartHasSaveData() {
+		auto cxi = mem.getCXI();
+		return (cxi != nullptr && cxi->hasSaveData());  // We need to have a CXI file with more than 0 bytes of save data
+	}
+};

include/services/fs.hpp

@@ -4,6 +4,7 @@
 #include "fs/archive_save_data.hpp"
 #include "fs/archive_sdmc.hpp"
 #include "fs/archive_self_ncch.hpp"
+#include "fs/archive_user_save_data.hpp"
 #include "helpers.hpp"
 #include "kernel_types.hpp"
 #include "logger.hpp"
@@ -26,6 +27,10 @@ class FSService {
 	SDMCArchive sdmc;
 	NCCHArchive ncch;
 
+	// UserSaveData archives
+	UserSaveDataArchive userSaveData1;
+	UserSaveDataArchive userSaveData2;
+
 	ExtSaveDataArchive extSaveData_sdmc;
 	ExtSaveDataArchive sharedExtSaveData_nand;
 
@@ -62,10 +67,9 @@ class FSService {
 	u32 priority;
 
 public:
-	FSService(Memory& mem, Kernel& kernel) : mem(mem), saveData(mem),
+	FSService(Memory& mem, Kernel& kernel)
-		sharedExtSaveData_nand(mem, "../SharedFiles/NAND", true), extSaveData_sdmc(mem, "SDMC"),
+		: mem(mem), saveData(mem), sharedExtSaveData_nand(mem, "../SharedFiles/NAND", true), extSaveData_sdmc(mem, "SDMC"), sdmc(mem), selfNcch(mem),
-		sdmc(mem), selfNcch(mem), ncch(mem), kernel(kernel)
+		  ncch(mem), userSaveData1(mem, ArchiveID::UserSaveData1), userSaveData2(mem, ArchiveID::UserSaveData2), kernel(kernel) {}
-	{}
 
 	void reset();
 	void handleSyncRequest(u32 messagePointer);

src/core/fs/archive_user_save_data.cpp

@@ -0,0 +1,198 @@
+#include <algorithm>
+#include <memory>
+
+#include "fs/archive_user_save_data.hpp"
+
+namespace fs = std::filesystem;
+
+HorizonResult UserSaveDataArchive::createFile(const FSPath& path, u64 size) {
+	if (path.type == PathType::UTF16) {
+		if (!isPathSafe<PathType::UTF16>(path)) Helpers::panic("Unsafe path in UserSaveData::CreateFile");
+
+		fs::path p = IOFile::getAppData() / "SaveData";
+		p += fs::path(path.utf16_string).make_preferred();
+
+		if (fs::exists(p)) return Result::FS::AlreadyExists;
+
+		IOFile file(p.string().c_str(), "wb");
+
+		// If the size is 0, leave the file empty and return success
+		if (size == 0) {
+			file.close();
+			return Result::Success;
+		}
+
+		// If it is not empty, seek to size - 1 and write a 0 to create a file of size "size"
+		else if (file.seek(size - 1, SEEK_SET) && file.writeBytes("", 1).second == 1) {
+			file.close();
+			return Result::Success;
+		}
+
+		file.close();
+		return Result::FS::FileTooLarge;
+	}
+
+	Helpers::panic("UserSaveDataArchive::OpenFile: Failed");
+	return Result::Success;
+}
+
+HorizonResult UserSaveDataArchive::createDirectory(const FSPath& path) {
+	if (path.type == PathType::UTF16) {
+		if (!isPathSafe<PathType::UTF16>(path)) Helpers::panic("Unsafe path in UserSaveData::OpenFile");
+
+		fs::path p = IOFile::getAppData() / "SaveData";
+		p += fs::path(path.utf16_string).make_preferred();
+
+		if (fs::is_directory(p)) return Result::FS::AlreadyExists;
+		if (fs::is_regular_file(p)) {
+			Helpers::panic("File path passed to UserSaveData::CreateDirectory");
+		}
+
+		bool success = fs::create_directory(p);
+		return success ? Result::Success : Result::FS::UnexpectedFileOrDir;
+	} else {
+		Helpers::panic("Unimplemented UserSaveData::CreateDirectory");
+	}
+}
+
+HorizonResult UserSaveDataArchive::deleteFile(const FSPath& path) {
+	if (path.type == PathType::UTF16) {
+		if (!isPathSafe<PathType::UTF16>(path)) Helpers::panic("Unsafe path in UserSaveData::DeleteFile");
+
+		fs::path p = IOFile::getAppData() / "SaveData";
+		p += fs::path(path.utf16_string).make_preferred();
+
+		if (fs::is_directory(p)) {
+			Helpers::panic("UserSaveData::DeleteFile: Tried to delete directory");
+		}
+
+		if (!fs::is_regular_file(p)) {
+			return Result::FS::FileNotFoundAlt;
+		}
+
+		std::error_code ec;
+		bool success = fs::remove(p, ec);
+
+		// It might still be possible for fs::remove to fail, if there's eg an open handle to a file being deleted
+		// In this case, print a warning, but still return success for now
+		if (!success) {
+			Helpers::warn("UserSaveData::DeleteFile: fs::remove failed\n");
+		}
+
+		return Result::Success;
+	}
+
+	Helpers::panic("UserSaveDataArchive::DeleteFile: Unknown path type");
+	return Result::Success;
+}
+
+FileDescriptor UserSaveDataArchive::openFile(const FSPath& path, const FilePerms& perms) {
+	if (path.type == PathType::UTF16) {
+		if (!isPathSafe<PathType::UTF16>(path)) Helpers::panic("Unsafe path in UserSaveData::OpenFile");
+
+		if (perms.raw == 0 || (perms.create() && !perms.write())) Helpers::panic("[UserSaveData] Unsupported flags for OpenFile");
+
+		fs::path p = IOFile::getAppData() / "SaveData";
+		p += fs::path(path.utf16_string).make_preferred();
+
+		const char* permString = perms.write() ? "r+b" : "rb";
+
+		if (fs::exists(p)) {  // Return file descriptor if the file exists
+			IOFile file(p.string().c_str(), permString);
+			return file.isOpen() ? file.getHandle() : FileError;
+		} else {
+			// If the file is not found, create it if the create flag is on
+			if (perms.create()) {
+				IOFile file(p.string().c_str(), "wb");  // Create file
+				file.close();                           // Close it
+
+				file.open(p.string().c_str(), permString);  // Reopen with proper perms
+				return file.isOpen() ? file.getHandle() : FileError;
+			} else {
+				return FileError;
+			}
+		}
+	}
+
+	Helpers::panic("UserSaveDataArchive::OpenFile: Failed");
+	return FileError;
+}
+
+Rust::Result<DirectorySession, HorizonResult> UserSaveDataArchive::openDirectory(const FSPath& path) {
+	if (path.type == PathType::UTF16) {
+		if (!isPathSafe<PathType::UTF16>(path)) Helpers::panic("Unsafe path in UserSaveData::OpenDirectory");
+
+		fs::path p = IOFile::getAppData() / "SaveData";
+		p += fs::path(path.utf16_string).make_preferred();
+
+		if (fs::is_regular_file(p)) {
+			printf("SaveData: OpenDirectory used with a file path");
+			return Err(Result::FS::UnexpectedFileOrDir);
+		}
+
+		if (fs::is_directory(p)) {
+			return Ok(DirectorySession(this, p));
+		} else {
+			return Err(Result::FS::FileNotFoundAlt);
+		}
+	}
+
+	Helpers::panic("UserSaveDataArchive::OpenDirectory: Unimplemented path type");
+	return Err(Result::Success);
+}
+
+Rust::Result<ArchiveBase::FormatInfo, HorizonResult> UserSaveDataArchive::getFormatInfo(const FSPath& path) {
+	const fs::path formatInfoPath = getFormatInfoPath();
+	IOFile file(formatInfoPath, "rb");
+
+	// If the file failed to open somehow, we return that the archive is not formatted
+	if (!file.isOpen()) {
+		return Err(Result::FS::NotFormatted);
+	}
+
+	FormatInfo ret;
+	auto [success, bytesRead] = file.readBytes(&ret, sizeof(FormatInfo));
+	file.close();
+
+	if (!success || bytesRead != sizeof(FormatInfo)) {
+		Helpers::warn("UserSaveData::GetFormatInfo: Format file exists but was not properly read into the FormatInfo struct");
+		return Err(Result::FS::NotFormatted);
+	}
+
+	return Ok(ret);
+}
+
+void UserSaveDataArchive::format(const FSPath& path, const ArchiveBase::FormatInfo& info) {
+	const fs::path saveDataPath = IOFile::getAppData() / "SaveData";
+	const fs::path formatInfoPath = getFormatInfoPath();
+
+	// Delete all contents by deleting the directory then recreating it
+	fs::remove_all(saveDataPath);
+	fs::create_directories(saveDataPath);
+
+	// Write format info on disk
+	IOFile file(formatInfoPath, "wb");
+	file.writeBytes(&info, sizeof(info));
+	file.flush();
+	file.close();
+}
+
+Rust::Result<ArchiveBase*, HorizonResult> UserSaveDataArchive::openArchive(const FSPath& path) {
+	if (path.type != PathType::Binary) {
+		Helpers::panic("Unimplemented path type for UserSaveData archive: %d\n", path.type);
+		return Err(Result::FS::NotFoundInvalid);
+	}
+
+	const fs::path formatInfoPath = getFormatInfoPath();
+	// Format info not found so the archive is not formatted
+	if (!fs::is_regular_file(formatInfoPath)) {
+		return Err(Result::FS::NotFormatted);
+	}
+
+	return Ok((ArchiveBase*)this);
+}
+
+std::optional<u32> UserSaveDataArchive::readFile(FileSession* file, u64 offset, u32 size, u32 dataPointer) {
+	Helpers::panic("Unimplemented UserSaveData::ReadFile");
+	return 0;
+}

src/core/services/fs.cpp

@@ -70,6 +70,8 @@ ArchiveBase* FSService::getArchiveFromID(u32 id, const FSPath& archivePath) {
 	switch (id) {
 		case ArchiveID::SelfNCCH: return &selfNcch;
 		case ArchiveID::SaveData: return &saveData;
+		case ArchiveID::UserSaveData2: return &userSaveData2;
+
 		case ArchiveID::ExtSaveData:
 			return &extSaveData_sdmc;