[Kernel] Hopefully implement the QueryMemory svc remotely correctly

include/kernel/kernel.hpp

@@ -69,6 +69,8 @@ class Kernel {
 	void createAddressArbiter();
 	void createEvent();
 	void controlMemory();
+	void mapMemoryBlock();
+	void queryMemory();
 	void getResourceLimit();
 	void getResourceLimitLimitValues();
 	void getResourceLimitCurrentValues();

include/memory.hpp

@@ -26,11 +26,49 @@ namespace VirtualAddrs {
 	};
 }
 
+// Types for svcQueryMemory
+namespace KernelMemoryTypes {
+	// This makes no sense
+	enum MemoryState : u32 {
+		Free = 0,
+		Reserved = 1,
+		IO = 2,
+		Static = 3,
+		Code = 4,
+		Private = 5,
+		Shared = 6,
+		Continuous = 7,
+		Aliased = 8,
+		Alias = 9,
+		AliasCode = 10,
+		Locked = 11,
+
+		PERMISSION_R = 1 << 0,
+		PERMISSION_W = 1 << 1,
+		PERMISSION_X = 1 << 2
+	};
+	
+	// I assume this is referring to a single piece of allocated memory? If it's for pages, it makes no sense.
+	// If it's for multiple allocations, it also makes no sense
+	struct MemoryInfo {
+		u32 baseVaddr; // Base process virtual address. TODO: What even is this
+		u32 size;      // Of what?
+		u32 perms;     // Is this referring to a single page or?
+		u32 state;
+
+		u32 end() { return baseVaddr + size; }
+		MemoryInfo(u32 baseVaddr, u32 size, u32 perms, u32 state) : baseVaddr(baseVaddr), size(size)
+			, perms(perms), state(state) {}
+	};
+}
+
 class Memory {
 	u8* fcram;
 
 	// Our dynarmic core uses page tables for reads and writes with 4096 byte pages
 	std::vector<uintptr_t> readTable, writeTable;
+	std::vector<KernelMemoryTypes::MemoryInfo> memoryInfo;
+
 	static constexpr u32 pageShift = 12;
 	static constexpr u32 pageSize = 1 << pageShift;
 	static constexpr u32 pageMask = pageSize - 1;
@@ -76,4 +114,5 @@ public:
 	}
 
 	std::string readString(u32 vaddr, u32 maxCharacters);
+	KernelMemoryTypes::MemoryInfo queryMemory(u32 vaddr);
 };

src/core/kernel/kernel.cpp

@@ -5,6 +5,7 @@
 void Kernel::serviceSVC(u32 svc) {
 	switch (svc) {
 		case 0x01: controlMemory(); break;
+		case 0x02: queryMemory(); break;
 		case 0x17: createEvent(); break;
 		case 0x21: createAddressArbiter(); break;
 		case 0x23: svcCloseHandle(); break;

src/core/kernel/memory_management.cpp

@@ -67,4 +67,26 @@ void Kernel::controlMemory() {
 	}
 
 	regs[0] = SVCResult::Success;
+}
+
+// Result QueryMemory(MemoryInfo* memInfo, PageInfo* pageInfo, u32 addr)
+void Kernel::queryMemory() {
+	const u32 memInfo = regs[0];
+	const u32 pageInfo = regs[1];
+	const u32 addr = regs[2];
+
+	if (addr & 0xfff) {
+		Helpers::panic("QueryMemory: Address not page aligned\n");
+	}
+
+	printf("QueryMemory(mem info pointer = %08X, page info pointer = %08X, addr = %08X)\n", memInfo, pageInfo, addr);
+
+	const auto info = mem.queryMemory(addr);
+	regs[0] = SVCResult::Success;
+
+	mem.write32(memInfo, info.baseVaddr); // Set memInfo->baseVaddr
+	mem.write32(memInfo + 4, info.size); // Set memInfo->size
+	mem.write32(memInfo + 8, info.baseVaddr); // Set memInfo->perms
+	mem.write32(memInfo + 12, info.state); // Set memInfo->state
+	mem.write32(pageInfo, 0); // Set pageInfo->flags to 0
 }

src/core/memory.cpp

@@ -2,14 +2,18 @@
 #include "config_mem.hpp"
 #include <cassert>
 
+using namespace KernelMemoryTypes;
+
 Memory::Memory() {
 	fcram = new uint8_t[FCRAM_SIZE]();
 	readTable.resize(totalPageCount, 0);
 	writeTable.resize(totalPageCount, 0);
+	memoryInfo.reserve(32); // Pre-allocate some room for memory allocation info to avoid dynamic allocs
 }
 
 void Memory::reset() {
 	// Unallocate all memory
+	memoryInfo.clear();
 	usedFCRAMPages.reset();
 	usedUserMemory = 0_MB;
 
@@ -76,13 +80,17 @@ std::optional<u32> Memory::allocateMemory(u32 vaddr, u32 paddr, u32 size, bool l
 		if (w) {
 			writeTable[virtualPage] = uintptr_t(&fcram[physPage * pageSize]);
 		}
-		
+
 		// Mark FCRAM page as allocated and go on
 		usedFCRAMPages[physPage] = true;
 		virtualPage++;
 		physPage++;
 	}
-	
+
+	// Back up the info for this allocation in our memoryInfo vector
+	u32 perms = (r ? PERMISSION_R : 0) | (w ? PERMISSION_W : 0) | (x ? PERMISSION_X : 0);
+	memoryInfo.push_back(std::move(MemoryInfo(vaddr, size, perms, KernelMemoryTypes::Reserved)));
+
 	return vaddr;
 }
 
@@ -218,4 +226,20 @@ std::string Memory::readString(u32 address, u32 maxSize) {
 	string.shrink_to_fit();
 
 	return string;
+}
+
+// The way I understand how the kernel's QueryMemory is supposed to work is that you give it a vaddr
+// And the kernel looks up the memory allocations it's performed, finds which one it belongs in and returns its info?
+// TODO: Verify this
+MemoryInfo Memory::queryMemory(u32 vaddr) {
+	// Check each allocation
+	for (auto& alloc : memoryInfo) {
+		// Check if the memory address belongs in this allocation and return the info if so
+		if (vaddr >= alloc.baseVaddr && vaddr < alloc.end()) {
+			return alloc;
+		}
+	}
+
+	// Otherwise, if this vaddr was never allocated
+	return MemoryInfo(vaddr, 0, 0, KernelMemoryTypes::Free);
 }

src/core/services/gsp_gpu.cpp

@@ -12,7 +12,7 @@ namespace GPUCommands {
 namespace Result {
 	enum : u32 {
 		Success = 0,
-		SuccessRegisterIRQ = 0x2A07
+		SuccessRegisterIRQ = 0x2A07 // TODO: Is this a reference to the Ricoh 2A07 used in PAL NES systems?
 	};
 }
 

src/main.cpp

@@ -11,5 +11,6 @@ int main (int argc, char *argv[]) {
     if (!emu.loadELF(elfPath)) {
         Helpers::panic("Failed to load ELF file: %s", elfPath.c_str());
     }
+
     emu.run();
 }