Implement reading from RomFS

CMakeLists.txt

@@ -61,6 +61,7 @@ set(PICA_SOURCE_FILES src/core/PICA/gpu.cpp src/core/PICA/regs.cpp src/core/PICA
                       src/core/PICA/shader_interpreter.cpp src/core/PICA/renderer_opengl.cpp
 )
 set(LOADER_SOURCE_FILES src/core/loader/elf.cpp src/core/loader/ncsd.cpp src/core/loader/ncch.cpp)
+set(FS_SOURCE_FILES src/core/filesystem/archive_ncch.cpp)
 
 set(HEADER_FILES include/emulator.hpp include/helpers.hpp include/opengl.hpp include/termcolor.hpp
                  include/cpu.hpp include/cpu_dynarmic.hpp include/memory.hpp include/kernel/kernel.hpp
@@ -85,12 +86,13 @@ set(THIRD_PARTY_SOURCE_FILES third_party/imgui/imgui.cpp
 #add_library(Alber ${HEADER_FILES})
 source_group("Header Files\\Core" FILES ${HEADER_FILES})
 source_group("Source Files\\Core" FILES ${SOURCE_FILES})
-source_group("Source Files\\Loader" FILES ${LOADER_SOURCE_FILES})
+source_group("Source Files\\Core\\Filesystem" FILES ${FS_SOURCE_FILES})
 source_group("Source Files\\Core\\Kernel" FILES ${KERNEL_SOURCE_FILES})
+source_group("Source Files\\Core\\Loader" FILES ${LOADER_SOURCE_FILES})
 source_group("Source Files\\Core\\Services" FILES ${SERVICE_SOURCE_FILES})
 source_group("Source Files\\Core\\PICA" FILES ${PICA_SOURCE_FILES})
 source_group("Source Files\\Third Party" FILES ${THIRD_PARTY_SOURCE_FILES})
 
-add_executable(Alber ${SOURCE_FILES} ${LOADER_SOURCE_FILES} ${KERNEL_SOURCE_FILES} ${SERVICE_SOURCE_FILES} ${PICA_SOURCE_FILES}
-${THIRD_PARTY_SOURCE_FILES} ${HEADER_FILES})
+add_executable(Alber ${SOURCE_FILES} ${FS_SOURCE_FILES} ${KERNEL_SOURCE_FILES} ${LOADER_SOURCE_FILES} ${SERVICE_SOURCE_FILES}
+${PICA_SOURCE_FILES} ${THIRD_PARTY_SOURCE_FILES} ${HEADER_FILES})
 target_link_libraries(Alber PRIVATE dynarmic SDL2-static)

include/fs/archive_base.hpp

@@ -44,6 +44,18 @@ struct FSPath {
     u32 pointer; // Pointer to the actual path data
 };
 
+class ArchiveBase;
+
+struct FileSession {
+    ArchiveBase* archive = nullptr;
+    FSPath path;
+    bool isOpen;
+
+    FileSession(ArchiveBase* archive, const FSPath& filePath, bool isOpen = true) : archive(archive), isOpen(isOpen) {
+        path = filePath;
+    }
+};
+
 class ArchiveBase {
 protected:
     using Result = u32;
@@ -56,6 +68,10 @@ public:
     virtual bool openFile(const FSPath& path) = 0;
 
     virtual ArchiveBase* openArchive(FSPath& path) = 0;
+
+    // Read size bytes from a file starting at offset "offset" into a certain buffer in memory
+    // Returns the number of bytes read, or nullopt if the read failed
+    virtual std::optional<u32> readFile(FileSession* file, u64 offset, u32 size, u32 dataPointer) = 0;
     
     ArchiveBase(Memory& mem) : mem(mem) {}
 };

include/fs/archive_ncch.hpp

@@ -4,25 +4,11 @@ class SelfNCCHArchive : public ArchiveBase {
 
 public:
 	SelfNCCHArchive(Memory& mem) : ArchiveBase(mem) {}
-	
+
 	u64 getFreeBytes() override { return 0; }
 	const char* name() override { return "SelfNCCH"; }
 
-	bool openFile(const FSPath& path) override {
-		if (path.type != PathType::Binary) {
-			printf("Invalid SelfNCCH path type");
-			return false;
-		}
-
-		return true;
-	}
-
-	ArchiveBase* openArchive(FSPath& path) override {
-		if (path.type != PathType::Empty) {
-			printf("Invalid path type for SelfNCCH archive: %d\n", path.type);
-			return nullptr;
-		}
-
-		return this;
-	}
+	bool openFile(const FSPath& path) override;
+	ArchiveBase* openArchive(FSPath& path) override;
+	std::optional<u32> readFile(FileSession* file, u64 offset, u32 size, u32 dataPointer) override;
 };

include/kernel/kernel.hpp

@@ -84,6 +84,7 @@ class Kernel {
 	MAKE_LOG_FUNCTION(logSVC, svcLogger)
 	MAKE_LOG_FUNCTION(logDebugString, debugStringLogger)
 	MAKE_LOG_FUNCTION(logError, errorLogger)
+	MAKE_LOG_FUNCTION(logFileIO, fileIOLogger)
 
 	// SVC implementations
 	void arbitrateAddress();
@@ -110,6 +111,7 @@ class Kernel {
 
 	// File operations
 	void handleFileOperation(u32 messagePointer, Handle file);
+	void closeFile(u32 messagePointer, Handle file);
 	void readFile(u32 messagePointer, Handle file);
 
 public:

include/kernel/kernel_types.hpp

@@ -93,15 +93,6 @@ struct Session {
     Session(Handle portHandle) : portHandle(portHandle) {}
 };
 
-struct FileSession {
-    ArchiveBase* archive = nullptr;
-    FSPath path;
-
-    FileSession(ArchiveBase* archive, const FSPath& filePath) : archive(archive) {
-        path = filePath;
-    }
-};
-
 enum class ThreadStatus {
     Running,     // Currently running
     Ready,       // Ready to run

include/logger.hpp

@@ -21,6 +21,7 @@ namespace Log {
     static Logger<true> kernelLogger;
     static Logger<true> debugStringLogger; // Enables output for the outputDebugString SVC
     static Logger<true> errorLogger;
+    static Logger<true> fileIOLogger;
     static Logger<true> svcLogger;
     static Logger<true> gpuLogger;
 

include/memory.hpp

@@ -139,6 +139,14 @@ public:
 	u32 getLinearHeapVaddr();
 	u8* getFCRAM() { return fcram; }
 
+	NCCH* getCXI() {
+		if (loadedCXI.has_value()) {
+			return &loadedCXI.value();
+		} else {
+			return nullptr;
+		}
+	}
+
 	// Returns whether "addr" is aligned to a page (4096 byte) boundary
 	static constexpr bool isAligned(u32 addr) {
 		return (addr & pageMask) == 0;
@@ -165,4 +173,9 @@ public:
 	// TODO: Find out
 	// Returns a pointer to the FCRAM block used for the memory if allocation succeeded
 	u8* mapSharedMemory(Handle handle, u32 vaddr, u32 myPerms, u32 otherPerms);
+
+	// Backup of the game's CXI partition info, if any
+	std::optional<NCCH> loadedCXI = std::nullopt;
+	// File handle for reading the loaded ncch
+	IOFile CXIFile;
 };

src/core/filesystem/archive_ncch.cpp

@@ -0,0 +1,62 @@
+#include "fs/archive_ncch.hpp"
+#include <memory>
+
+bool SelfNCCHArchive::openFile(const FSPath& path) {
+	if (path.type != PathType::Binary) {
+		printf("Invalid SelfNCCH path type");
+		return false;
+	}
+
+	// We currently only know how to read from an NCCH's RomFS
+	if (mem.read32(path.pointer) != 0) {
+		Helpers::panic("Read from NCCH's non-RomFS section!");
+	}
+
+	return true;
+}
+
+ArchiveBase* SelfNCCHArchive::openArchive(FSPath& path) {
+	if (path.type != PathType::Empty) {
+		printf("Invalid path type for SelfNCCH archive: %d\n", path.type);
+		return nullptr;
+	}
+
+	return this;
+}
+
+std::optional<u32> SelfNCCHArchive::readFile(FileSession* file, u64 offset, u32 size, u32 dataPointer) {
+	auto cxi = mem.getCXI();
+	if (cxi == nullptr) {
+		Helpers::panic("Tried to read file from non-existent CXI");
+		return std::nullopt;
+	}
+
+	if (!cxi->hasRomFS()) {
+		Helpers::panic("Tried to read from CXI without RomFS");
+	}
+
+	const u32 romFSSize = cxi->romFS.size;
+	const u32 romFSOffset = cxi->romFS.offset;
+	if ((offset >> 32) || (offset >= romFSSize) || (offset + size >= romFSSize)) {
+		Helpers::panic("Tried to read from SelfNCCH with too big of an offset");
+	}
+
+	IOFile& ioFile = mem.CXIFile;
+	if (!ioFile.seek(cxi->fileOffset + romFSOffset + offset)) {
+		Helpers::panic("Failed to seek while reading from RomFS");
+	}
+
+	std::unique_ptr<u8[]> data(new u8[size]);
+	auto [success, bytesRead] = ioFile.readBytes(&data[0], size);
+
+	if (!success) {
+		Helpers::panic("Failed to read from RomFS");
+	}
+
+	for (u64 i = 0; i < bytesRead; i++) {
+		mem.write8(dataPointer + i, data[i]);
+		printf("%x\n", data[i]);
+	}
+
+	return bytesRead;
+}

src/core/kernel/file_operations.cpp

@@ -2,17 +2,64 @@
 
 namespace FileOps {
 	enum : u32 {
-		Read = 0x080200C2
+		Read = 0x080200C2,
+		Close = 0x08080000
 	};
 }
 
+namespace Result {
+	enum : u32 {
+		Success = 0
+	};
+}
+
+
 void Kernel::handleFileOperation(u32 messagePointer, Handle file) {
 	const u32 cmd = mem.read32(messagePointer);
 	switch (cmd) {
+		case FileOps::Close: closeFile(messagePointer, file); break;
+		case FileOps::Read: readFile(messagePointer, file); break;
 		default: Helpers::panic("Unknown file operation: %08X", cmd);
 	}
 }
 
-void Kernel::readFile(u32 messagePointer, Handle file) {
-	
+void Kernel::closeFile(u32 messagePointer, Handle fileHandle) {
+	logFileIO("Closed file %X\n", fileHandle);
+
+	const auto p = getObject(fileHandle, KernelObjectType::File);
+	if (p == nullptr) [[unlikely]] {
+		Helpers::panic("Called CloseFile on non-existent file");
+	}
+
+	p->getData<FileSession>()->isOpen = false;
+	mem.write32(messagePointer + 4, Result::Success);
+}
+
+void Kernel::readFile(u32 messagePointer, Handle fileHandle) {
+	u64 offset = mem.read64(messagePointer + 4);
+	u32 size = mem.read32(messagePointer + 12);
+	u32 dataPointer = mem.read32(messagePointer + 20);
+
+	logFileIO("Trying to read %X bytes from file %X, starting from offset %llX into memory address %08X\n",
+		size, fileHandle, offset, dataPointer);
+
+	const auto p = getObject(fileHandle, KernelObjectType::File);
+	if (p == nullptr) [[unlikely]] {
+		Helpers::panic("Called ReadFile on non-existent file");
+	}
+
+	FileSession* file = p->getData<FileSession>();
+	if (!file->isOpen) {
+		Helpers::panic("Tried to read closed file");
+	}
+
+	auto archive = file->archive;
+
+	std::optional<u32> bytesRead = archive->readFile(file, offset, size, dataPointer);
+	if (!bytesRead.has_value()) {
+		Helpers::panic("Kernel::ReadFile failed");
+	} else {
+		mem.write32(messagePointer + 4, Result::Success);
+		mem.write32(messagePointer + 8, bytesRead.value());
+	}
 }

src/core/loader/ncsd.cpp

@@ -118,5 +118,9 @@ std::optional<NCSD> Memory::loadNCSD(const std::filesystem::path& path) {
 
     ncsd.entrypoint = textAddr;
 
+    // Back the IOFile for accessing the ROM, as well as the ROM's CXI partition, in the memory class.
+    CXIFile = ncsd.file;
+    loadedCXI = cxi;
+
     return ncsd;
 }