Merge remote-tracking branch 'upstream/master' into moar-gpu

src/core/fs/ivfc.cpp

@@ -58,7 +58,7 @@ namespace IVFC {
 
 		// According to 3DBrew, this is usually the case but not guaranteed
 		if (ivfcActualSize != ivfcDescriptorSize) {
-			printf("IVFC descriptor size mismatch: %lx != %lx\n", ivfcActualSize, ivfcDescriptorSize);
+			printf("IVFC descriptor size mismatch: %llx != %llx\n", ivfcActualSize, ivfcDescriptorSize);
 		}
 
 		if (magicIdentifier == 0x10000 && ivfcActualSize != 0x5C) {
@@ -73,4 +73,4 @@ namespace IVFC {
 
 		return ivfcActualSize;
 	}
-}  // namespace IVFC
+}  // namespace IVFC

src/core/kernel/kernel.cpp

@@ -6,6 +6,7 @@
 Kernel::Kernel(CPU& cpu, Memory& mem, GPU& gpu)
 	: 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
+	mutexHandles.reserve(8);
 	portHandles.reserve(32);
 	threadIndices.reserve(appResourceLimits.maxThreads);
 
@@ -139,6 +140,7 @@ void Kernel::reset() {
 		deleteObjectData(object);
 	}
 	objects.clear();
+	mutexHandles.clear();
 	portHandles.clear();
 	threadIndices.clear();
 	serviceManager.reset();
@@ -256,6 +258,7 @@ void Kernel::duplicateHandle() {
 
 namespace SystemInfoType {
 	enum : u32 {
+		MemoryInformation = 0,
 		// Gets information related to Citra (We don't implement this, we just report this emulator is not Citra)
 		CitraInformation = 0x20000,
 		// Gets information related to this emulator
@@ -292,6 +295,22 @@ void Kernel::getSystemInfo() {
 
 	regs[0] = Result::Success;
 	switch (infoType) {
+		case SystemInfoType::MemoryInformation: {
+			switch (subtype) {
+				// Total used memory size in the APPLICATION memory region
+				case 1:
+					regs[1] = mem.getUsedUserMem();
+					regs[2] = 0;
+					break;
+
+				default:
+					Helpers::panic("GetSystemInfo: Unknown MemoryInformation subtype %x\n", subtype);
+					regs[0] = Result::FailurePlaceholder;
+					break;
+			}
+			break;
+		}
+
 		case SystemInfoType::CitraInformation: {
 			switch (subtype) {
 				case CitraInfoType::IsCitra:

src/core/kernel/threads.cpp

@@ -168,6 +168,11 @@ Handle Kernel::makeMutex(bool locked) {
 		moo->ownerThread = currentThreadIndex;
 	}
 
+	// Push the new mutex to our list of mutex handles
+	// We need a list of mutex handles so that when a thread is killed, we can look which mutexes from this list the thread owns and free them
+	// Alternatively this could be a per-thread list, but I don't want to push_back and remove on every mutex lock and release
+	// Since some mutexes like the APT service mutex are locked and unlocked constantly, while ExitThread is a relatively "rare" SVC
+	mutexHandles.push_back(ret);
 	return ret;
 }
 
@@ -466,6 +471,23 @@ void Kernel::setThreadPriority() {
 void Kernel::exitThread() {
 	logSVC("ExitThread\n");
 
+	// Find which mutexes this thread owns, release them
+	for (auto handle : mutexHandles) {
+		KernelObject* object = getObject(handle, KernelObjectType::Mutex);
+
+		// Make sure that the handle actually matches to a mutex, and if our exiting thread owns the mutex, release it
+		if (object != nullptr) {
+			Mutex* moo = object->getData<Mutex>();
+
+			if (moo->locked && moo->ownerThread == currentThreadIndex) {
+				// Release the mutex by setting lock count to 1 and releasing it once. We set lock count to 1 since it's a recursive mutex
+				// Therefore if its lock count was > 1, simply calling releaseMutex would not fully release it
+				moo->lockCount = 1;
+				releaseMutex(moo);
+			}
+		}
+	}
+
 	// Remove the index of this thread from the thread indices vector
 	for (int i = 0; i < threadIndices.size(); i++) {
 		if (threadIndices[i] == currentThreadIndex)

src/core/memory.cpp

@@ -91,6 +91,12 @@ u8 Memory::read8(u32 vaddr) {
 			case ConfigMem::NetworkState: return 2;  // Report that we've got an internet connection
 			case ConfigMem::HeadphonesConnectedMaybe: return 0;
 			case ConfigMem::Unknown1086: return 1;  // It's unknown what this is but some games want it to be 1
+
+			case ConfigMem::FirmUnknown: return firm.unk;
+			case ConfigMem::FirmRevision: return firm.revision;
+			case ConfigMem::FirmVersionMinor: return firm.minor;
+			case ConfigMem::FirmVersionMajor: return firm.major;
+
 			default: Helpers::panic("Unimplemented 8-bit read, addr: %08X", vaddr);
 		}
 	}
@@ -138,6 +144,8 @@ u32 Memory::read32(u32 vaddr) {
 
 			// 3D slider. Float in range 0.0 = off, 1.0 = max.
 			case ConfigMem::SliderState3D: return Helpers::bit_cast<u32, float>(0.0f);
+			case ConfigMem::FirmUnknown:
+				return u32(read8(vaddr)) | (u32(read8(vaddr + 1)) << 8) | (u32(read8(vaddr + 2)) << 16) | (u32(read8(vaddr + 3)) << 24);
 
 			default:
 				if (vaddr >= VirtualAddrs::VramStart && vaddr < VirtualAddrs::VramStart + VirtualAddrs::VramSize) {

src/core/services/apt.cpp

@@ -2,6 +2,8 @@
 #include "ipc.hpp"
 #include "kernel.hpp"
 
+#include <vector>
+
 namespace APTCommands {
 	enum : u32 {
 		GetLockHandle = 0x00010040,
@@ -94,10 +96,24 @@ void APTService::appletUtility(u32 messagePointer) {
 	u32 outputSize = mem.read32(messagePointer + 12);
 	u32 inputPointer = mem.read32(messagePointer + 20);
 
-	log("APT::AppletUtility(utility = %d, input size = %x, output size = %x, inputPointer = %08X) (Stubbed)\n", utility, inputSize,
-		outputSize, inputPointer);
+	log("APT::AppletUtility(utility = %d, input size = %x, output size = %x, inputPointer = %08X) (Stubbed)\n", utility, inputSize, outputSize,
+		inputPointer);
+
+	std::vector<u8> out(outputSize);
+	const u32 outputBuffer = mem.read32(messagePointer + 0x104);
+
+	if (outputSize >= 1 && utility == 6) {
+		// TryLockTransition expects a bool indicating success in the output buffer. Set it to true to avoid games panicking (Thanks to Citra)
+		out[0] = true;
+	}
+
 	mem.write32(messagePointer, IPC::responseHeader(0x4B, 2, 2));
 	mem.write32(messagePointer + 4, Result::Success);
+	mem.write32(messagePointer + 8, Result::Success);
+
+	for (u32 i = 0; i < outputSize; i++) {
+		mem.write8(outputBuffer + i, out[i]);
+	}
 }
 
 void APTService::preloadLibraryApplet(u32 messagePointer) {

src/core/services/fs.cpp

@@ -499,6 +499,12 @@ void FSService::controlArchive(u32 messagePointer) {
 		case 0: // Commit save data changes. Shouldn't need us to do anything
 			mem.write32(messagePointer + 4, Result::Success);
 			break;
+
+		case 1: // Retrieves a file's last-modified timestamp. Seen in DDLC, stubbed for the moment
+			Helpers::warn("FS::ControlArchive: Tried to retrieve a file's last-modified timestamp");
+			mem.write32(messagePointer + 4, Result::Success);
+			break;
+
 		default:
 			Helpers::panic("Unimplemented action for ControlArchive (action = %X)\n", action);
 			break;

src/core/services/service_manager.cpp

@@ -8,7 +8,8 @@
 ServiceManager::ServiceManager(std::span<u32, 16> regs, Memory& mem, GPU& gpu, u32& currentPID, Kernel& kernel)
 	: regs(regs), mem(mem), kernel(kernel), ac(mem), am(mem), boss(mem), act(mem), apt(mem, kernel), cam(mem), cecd(mem, kernel), cfg(mem),
 	  dlp_srvr(mem), dsp(mem, kernel), hid(mem, kernel), http(mem), ir_user(mem, kernel), frd(mem), fs(mem, kernel),
-	  gsp_gpu(mem, gpu, kernel, currentPID), gsp_lcd(mem), ldr(mem), mic(mem), nfc(mem, kernel), nim(mem), ndm(mem), ptm(mem), y2r(mem, kernel) {}
+	  gsp_gpu(mem, gpu, kernel, currentPID), gsp_lcd(mem), ldr(mem), mic(mem), nfc(mem, kernel), nim(mem), ndm(mem), ptm(mem), soc(mem),
+	  y2r(mem, kernel) {}
 
 static constexpr int MAX_NOTIFICATION_COUNT = 16;
 
@@ -36,6 +37,7 @@ void ServiceManager::reset() {
 	nim.reset();
 	ndm.reset();
 	ptm.reset();
+	soc.reset();
 	y2r.reset();
 
 	notificationSemaphore = std::nullopt;
@@ -95,7 +97,8 @@ static std::map<std::string, Handle> serviceMap = {
 	{ "boss:U", KernelHandles::BOSS },
 	{ "cam:u", KernelHandles::CAM },
 	{ "cecd:u", KernelHandles::CECD },
-	{ "cfg:u", KernelHandles::CFG },
+	{ "cfg:u", KernelHandles::CFG_U },
+	{ "cfg:i", KernelHandles::CFG_I },
 	{ "dlp:SRVR", KernelHandles::DLP_SRVR },
 	{ "dsp::DSP", KernelHandles::DSP },
 	{ "hid:USER", KernelHandles::HID },
@@ -112,6 +115,7 @@ static std::map<std::string, Handle> serviceMap = {
 	{ "nim:aoc", KernelHandles::NIM },
 	{ "ptm:u", KernelHandles::PTM }, // TODO: ptm:u and ptm:sysm have very different command sets
 	{ "ptm:sysm", KernelHandles::PTM },
+	{ "soc:U", KernelHandles::SOC },
 	{ "y2r:u", KernelHandles::Y2R }
 };
 // clang-format on
@@ -181,7 +185,7 @@ void ServiceManager::sendCommandToService(u32 messagePointer, Handle handle) {
         case KernelHandles::BOSS: boss.handleSyncRequest(messagePointer); break;
 		case KernelHandles::CAM: cam.handleSyncRequest(messagePointer); break;
 		case KernelHandles::CECD: cecd.handleSyncRequest(messagePointer); break;
-		case KernelHandles::CFG: cfg.handleSyncRequest(messagePointer); break;
+		case KernelHandles::CFG_U: cfg.handleSyncRequest(messagePointer); break;
 		case KernelHandles::DLP_SRVR: dlp_srvr.handleSyncRequest(messagePointer); break;
 		case KernelHandles::HID: hid.handleSyncRequest(messagePointer); break;
 		case KernelHandles::HTTP: http.handleSyncRequest(messagePointer); break;
@@ -194,6 +198,7 @@ void ServiceManager::sendCommandToService(u32 messagePointer, Handle handle) {
         case KernelHandles::NIM: nim.handleSyncRequest(messagePointer); break;
 		case KernelHandles::NDM: ndm.handleSyncRequest(messagePointer); break;
 		case KernelHandles::PTM: ptm.handleSyncRequest(messagePointer); break;
+		case KernelHandles::SOC: soc.handleSyncRequest(messagePointer); break;
 		case KernelHandles::Y2R: y2r.handleSyncRequest(messagePointer); break;
 		default: Helpers::panic("Sent IPC message to unknown service %08X\n Command: %08X", handle, mem.read32(messagePointer));
 	}

src/core/services/soc.cpp

@@ -0,0 +1,33 @@
+#include "services/soc.hpp"
+
+#include "ipc.hpp"
+#include "result/result.hpp"
+
+namespace SOCCommands {
+	enum : u32 {
+		InitializeSockets = 0x00010044,
+	};
+}
+
+void SOCService::reset() { initialized = false; }
+
+void SOCService::handleSyncRequest(u32 messagePointer) {
+	const u32 command = mem.read32(messagePointer);
+	switch (command) {
+		case SOCCommands::InitializeSockets: initializeSockets(messagePointer); break;
+		default: Helpers::panic("SOC service requested. Command: %08X\n", command);
+	}
+}
+
+void SOCService::initializeSockets(u32 messagePointer) {
+	const u32 memoryBlockSize = mem.read32(messagePointer + 4);
+	const Handle sharedMemHandle = mem.read32(messagePointer + 20);
+	log("SOC::InitializeSockets (memory block size = %08X, shared mem handle = %08X)\n", memoryBlockSize, sharedMemHandle);
+
+	// TODO: Does double initialization return an error code?
+	// TODO: Implement the rest of this stuff when it's time to do online. Also implement error checking for the size, shared mem handle, and so on
+	initialized = true;
+
+	mem.write32(messagePointer, IPC::responseHeader(0x01, 1, 0));
+	mem.write32(messagePointer + 4, Result::Success);
+}