[Kernel] More cleanup

include/kernel/kernel_types.hpp

@@ -1,4 +1,5 @@
 #pragma once
+#include <cstring>
 #include "handles.hpp"
 #include "helpers.hpp"
 
@@ -57,24 +58,33 @@ struct ResourceLimits {
     s32 currentCommit = 0;
 };
 
-struct ProcessData {
+struct Process {
     // Resource limits for this process
     ResourceLimits limits;
 };
 
-struct EventData {
+struct Event {
     ResetType resetType = RESET_ONESHOT;
+
+    Event(ResetType resetType) : resetType(resetType) {}
 };
 
-struct PortData {
+struct Port {
     static constexpr u32 maxNameLen = 11;
 
     char name[maxNameLen + 1] = {};
     bool isPublic = false; // Setting name=NULL creates a private port not accessible from svcConnectToPort.
+
+    Port(const char* name) {
+        // If the name is empty (ie the first char is the null terminator) then the port is private
+        isPublic = name[0] != '\0';
+        std::strncpy(this->name, name, maxNameLen);
+    }
 };
 
-struct SessionData {
+struct Session {
     Handle portHandle; // The port this session is subscribed to
+    Session(Handle portHandle) : portHandle(portHandle) {}
 };
 
 struct Thread {
@@ -106,4 +116,9 @@ struct KernelObject {
     // Our destructor does not free the data in order to avoid it being freed when our std::vector is expanded
     // Thus, the kernel needs to delete it when appropriate
     ~KernelObject() {}
+
+    template <typename T>
+    T* getData() {
+        return static_cast<T*>(data);
+    }
 };

src/core/kernel/events.cpp

@@ -11,11 +11,7 @@ const char* Kernel::resetTypeToString(u32 type) {
 
 Handle Kernel::makeEvent(ResetType resetType) {
 	Handle ret = makeObject(KernelObjectType::Event);
-	objects[ret].data = new EventData();
+	objects[ret].data = new Event(resetType);
-
-	auto eventData = static_cast<EventData*>(objects[ret].data);
-	eventData->resetType = resetType;
-
 	return ret;
 }
 

src/core/kernel/kernel.cpp

@@ -26,8 +26,8 @@ Handle Kernel::makeProcess() {
 	const Handle resourceLimitHandle = makeObject(KernelObjectType::ResourceLimit);
 
 	// Allocate data
-	objects[processHandle].data = new ProcessData();
+	objects[processHandle].data = new Process();
-	const auto processData = static_cast<ProcessData*>(objects[processHandle].data);
+	const auto processData = objects[processHandle].getData<Process>();
 
 	// Link resource limit object with its parent process
 	objects[resourceLimitHandle].data = &processData->limits;

src/core/kernel/ports.cpp

@@ -4,13 +4,7 @@
 Handle Kernel::makePort(const char* name) {
 	Handle ret = makeObject(KernelObjectType::Port);
 	portHandles.push_back(ret); // Push the port handle to our cache of port handles
-
+	objects[ret].data = new Port(name);
-	objects[ret].data = new PortData();
-	const auto data = static_cast<PortData*>(objects[ret].data);
-	std::strncpy(data->name, name, PortData::maxNameLen);
-
-	// If the name is empty (ie the first char is the null terminator) then the port is private
-	data->isPublic = name[0] != '\0';
 
 	// printf("Created %s port \"%s\" with handle %d\n", data->isPublic ? "public" : "private", data->name, ret);
 	return ret;
@@ -24,11 +18,7 @@ Handle Kernel::makeSession(Handle portHandle) {
 
 	// Allocate data for session
 	const Handle ret = makeObject(KernelObjectType::Session);
-	objects[ret].data = new SessionData();
+	objects[ret].data = new Session(portHandle);
-	auto sessionData = static_cast<SessionData*>(objects[ret].data);
-
-	// Link session with its parent port
-	sessionData->portHandle = portHandle;
 	return ret;
 }
 
@@ -36,8 +26,8 @@ Handle Kernel::makeSession(Handle portHandle) {
 // If there's no such port, return nullopt
 std::optional<Handle> Kernel::getPortHandle(const char* name) {
 	for (auto handle : portHandles) {
-		const auto data = static_cast<PortData*>(objects[handle].data);
+		const auto data = objects[handle].getData<Port>();
-		if (std::strncmp(name, data->name, PortData::maxNameLen) == 0) {
+		if (std::strncmp(name, data->name, Port::maxNameLen) == 0) {
 			return handle;
 		}
 	}
@@ -49,9 +39,9 @@ std::optional<Handle> Kernel::getPortHandle(const char* name) {
 void Kernel::connectToPort() {
 	const u32 handlePointer = regs[0];
 	// Read up to max + 1 characters to see if the name is too long
-	std::string port = mem.readString(regs[1], PortData::maxNameLen + 1);
+	std::string port = mem.readString(regs[1], Port::maxNameLen + 1);
 
-	if (port.size() > PortData::maxNameLen) {
+	if (port.size() > Port::maxNameLen) {
 		Helpers::panic("ConnectToPort: Port name too long\n");
 		regs[0] = SVCResult::PortNameTooLong;
 		return;
@@ -68,7 +58,7 @@ void Kernel::connectToPort() {
 	Handle portHandle = optionalHandle.value();
 	printf("ConnectToPort(handle pointer = %08X, port = \"%s\")\n", handlePointer, port.c_str());
 
-	const auto portData = static_cast<PortData*>(objects[portHandle].data);
+	const auto portData = objects[portHandle].getData<Port>();
 	if (!portData->isPublic) {
 		Helpers::panic("ConnectToPort: Attempted to connect to private port");
 	}
@@ -102,13 +92,13 @@ void Kernel::sendSyncRequest() {
 		return;
 	}
 
-	const auto sessionData = static_cast<SessionData*>(session->data);
+	const auto sessionData = static_cast<Session*>(session->data);
 	const Handle portHandle = sessionData->portHandle;
 
 	if (portHandle == srvHandle) { // Special-case SendSyncRequest targetting the "srv: port"
 		serviceManager.handleSyncRequest(messagePointer);
 	} else {
-		const auto portData = static_cast<PortData*>(objects[portHandle].data);
+		const auto portData = objects[portHandle].getData<Port>();
 		Helpers::panic("SendSyncRequest targetting port %s\n", portData->name);
 	}
 

src/core/kernel/resource_limits.cpp

@@ -14,7 +14,7 @@ void Kernel::getResourceLimit() {
 		return;
 	}
 
-	const auto processData = static_cast<ProcessData*>(process->data);
+	const auto processData = static_cast<Process*>(process->data);
 
 	regs[0] = SVCResult::Success;
 	regs[1] = processData->limits.handle;