Filesystem stuff

src/core/kernel/file_operations.cpp

@@ -0,0 +1,18 @@
+#include "kernel.hpp"
+
+namespace FileOps {
+	enum : u32 {
+		Read = 0x080200C2
+	};
+}
+
+void Kernel::handleFileOperation(u32 messagePointer, Handle file) {
+	const u32 cmd = mem.read32(messagePointer);
+	switch (cmd) {
+		default: Helpers::panic("Unknown file operation: %08X", cmd);
+	}
+}
+
+void Kernel::readFile(u32 messagePointer, Handle file) {
+	
+}

src/core/kernel/kernel.cpp

@@ -4,7 +4,7 @@
 #include "cpu.hpp"
 
 Kernel::Kernel(CPU& cpu, Memory& mem, GPU& gpu)
-	: cpu(cpu), regs(cpu.regs()), mem(mem), handleCounter(0), serviceManager(regs, mem, gpu, currentProcess) {
+	: cpu(cpu), regs(cpu.regs()), mem(mem), handleCounter(0), serviceManager(regs, mem, gpu, currentProcess, *this) {
 	objects.reserve(512); // Make room for a few objects to avoid further memory allocs later
 	portHandles.reserve(32);
 

src/core/kernel/ports.cpp

@@ -84,9 +84,18 @@ void Kernel::sendSyncRequest() {
 		return;
 	}
 
+	// Check if our sync request is targetting a file instead of a service
+	bool isFileOperation = getObject(handle, KernelObjectType::File) != nullptr;
+	if (isFileOperation) {
+		handleFileOperation(messagePointer, handle);
+		regs[0] = SVCResult::Success;
+		return;
+	}
+
+	// If we're actually communicating with a port
 	const auto session = getObject(handle, KernelObjectType::Session);
 	if (session == nullptr) [[unlikely]] {
-		Helpers::panic("SendSyncRequest: Invalid session handle");
+		Helpers::panic("SendSyncRequest: Invalid handle");
 		regs[0] = SVCResult::BadHandle;
 		return;
 	}

src/core/services/fs.cpp

@@ -1,4 +1,5 @@
 #include "services/fs.hpp"
+#include "kernel/kernel.hpp"
 
 namespace FSCommands {
 	enum : u32 {
@@ -17,6 +18,28 @@ namespace Result {
 
 void FSService::reset() {}
 
+ArchiveBase* FSService::getArchiveFromID(u32 id) {
+	switch (id) {
+		case ArchiveID::SelfNCCH: return &selfNcch;
+		default:
+			Helpers::panic("Unknown archive. ID: %d\n", id);
+			return nullptr;
+	}
+}
+
+std::optional<Handle> FSService::openFile(ArchiveBase* archive, const FSPath& path) {
+	bool opened = archive->openFile(path);
+	if (opened) {
+		auto handle = kernel.makeObject(KernelObjectType::File);
+		auto& file = kernel.getObjects()[handle];
+		file.data = new FileSession(archive, path);
+		
+		return handle;
+	} else {
+		return std::nullopt;
+	}
+}
+
 void FSService::handleSyncRequest(u32 messagePointer) {
 	const u32 command = mem.read32(messagePointer);
 	switch (command) {
@@ -48,9 +71,26 @@ void FSService::openFileDirectly(u32 messagePointer) {
 	const u32 archivePathPointer = mem.read32(messagePointer + 40);
 	const u32 filePathPointer = mem.read32(messagePointer + 48);
 
-	log("FS::OpenFileDirectly (failure)\n");
+	log("FS::OpenFileDirectly\n");
 
-	mem.write32(messagePointer + 4, Result::Success);
-	mem.write32(messagePointer + 12, 69);
-	//Helpers::panic("[FS::OpenFileDirectly] Tried to open file. Archive ID = %d\n", archiveID);
+	ArchiveBase* archive = getArchiveFromID(archiveID);
+	if (archive == nullptr) [[unlikely]] {
+		Helpers::panic("OpenFileDirectly: Tried to open unknown archive %d.", archiveID);
+	}
+
+	FSPath archivePath { .type = archivePathType, .size = archivePathSize, .pointer = archivePathPointer };
+	FSPath filePath { .type = filePathType, .size = filePathSize, .pointer = filePathPointer };
+
+	archive = archive->openArchive(archivePath);
+	if (archive == nullptr) [[unlikely]] {
+		Helpers::panic("OpenFileDirectly: Failed to open archive with given path");
+	}
+
+	std::optional<Handle> handle = openFile(archive, filePath);
+	if (!handle.has_value()) {
+		Helpers::panic("OpenFileDirectly: Failed to open file with given path");
+	} else {
+		mem.write32(messagePointer + 4, Result::Success);
+		mem.write32(messagePointer + 12, handle.value());
+	}
 }

src/core/services/service_manager.cpp

@@ -1,7 +1,7 @@
 #include "services/service_manager.hpp"
 
-ServiceManager::ServiceManager(std::array<u32, 16>& regs, Memory& mem, GPU& gpu, u32& currentPID)
-	: regs(regs), mem(mem), apt(mem), hid(mem), fs(mem), gsp_gpu(mem, gpu, currentPID), gsp_lcd(mem), ndm(mem) {}
+ServiceManager::ServiceManager(std::array<u32, 16>& regs, Memory& mem, GPU& gpu, u32& currentPID, Kernel& kernel)
+	: regs(regs), mem(mem), apt(mem), hid(mem), fs(mem, kernel), gsp_gpu(mem, gpu, currentPID), gsp_lcd(mem), ndm(mem) {}
 
 void ServiceManager::reset() {
 	apt.reset();