Lots of kernel work

include/kernel.hpp

@@ -1,22 +0,0 @@
-#pragma once
-#include <array>
-#include "helpers.hpp"
-#include "memory.hpp"
-
-namespace SVCResult {
-	enum : u32 {
-		Success = 0
-	};
-}
-
-class Kernel {
-	std::array<u32, 16>& regs;
-	Memory& mem;
-
-public:
-	Kernel(std::array<u32, 16>& regs, Memory& mem) : regs(regs), mem(mem) {}
-	void serviceSVC(u32 svc);
-	void reset();
-
-	void createAddressArbiter();
-};

include/kernel/kernel.hpp

@@ -0,0 +1,63 @@
+#pragma once
+#include <array>
+#include <limits>
+#include <string>
+#include <vector>
+#include "kernel_types.hpp"
+#include "helpers.hpp"
+#include "memory.hpp"
+
+class Kernel {
+	std::array<u32, 16>& regs;
+	Memory& mem;
+
+	// The handle number for the next kernel object to be created
+	u32 handleCounter;
+	std::vector<KernelObject> objects;
+
+	u32 currentProcess;
+
+	// Get pointer to the object with the specified handle
+	KernelObject* getObject(u32 handle) {
+		// Accessing an object that has not been created
+		if (handle >= objects.size()) [[unlikely]] {
+			return nullptr;
+		}
+
+		return &objects[handle];
+	}
+
+	// Get pointer to the object with the specified handle and type
+	KernelObject* getObject(u32 handle, KernelObjectType type) {
+		if (handle >= objects.size() || objects[handle].type != type) [[unlikely]] {
+			return nullptr;
+		}
+
+		return &objects[handle];
+	}
+
+	Handle makeObject(KernelObjectType type) {
+		if (handleCounter == std::numeric_limits<Handle>::max()) [[unlikely]] {
+			Helpers::panic("Hlep we somehow created enough kernel objects to overflow this thing");
+		}
+
+		objects.push_back(KernelObject(handleCounter, type));
+		printf("Created %s object with handle %d\n", kernelObjectTypeToString(type), handleCounter);
+		return handleCounter++;
+	}
+
+	Handle makeProcess();
+	KernelObject* getProcessFromPID(Handle handle);
+
+	void createAddressArbiter();
+	void getResourceLimit();
+	void getResourceLimitLimitValues();
+	std::string getProcessName(u32 pid);
+
+public:
+	Kernel(std::array<u32, 16>& regs, Memory& mem) : regs(regs), mem(mem), handleCounter(0) {
+		objects.reserve(512); // Make room for a few objects to avoid further memory allocs later
+	}
+	void serviceSVC(u32 svc);
+	void reset();
+};

include/kernel/kernel_types.hpp

@@ -0,0 +1,75 @@
+#pragma once
+#include "helpers.hpp"
+
+namespace SVCResult {
+	enum : u32 {
+		Success = 0,
+		Failure = 0xFFFFFFFF,
+        // Different calls return a different value
+        BadHandle = 0xD8E007F7,
+        BadHandleAlt = 0xD9001BF7
+	};
+}
+
+namespace KernelHandles {
+	enum : u32 {
+		CurrentThread = 0xFFFF8000,
+		CurrentProcess = 0xFFFF8001
+	};
+}
+
+enum class KernelObjectType : u8 {
+    ResourceLimit, Process
+};
+
+enum class ResourceLimitCategory : int {
+    Application = 0,
+    SystemApplet = 1,
+    LibraryApplet = 2,
+    Misc = 3
+};
+
+enum ResourceTypes {
+    PRIORITY = 0,
+    COMMIT = 1,
+    THREAD = 2,
+    EVENT = 3,
+    MUTEX = 4,
+    SEMAPHORE = 5,
+    TIMER = 6,
+    SHARED_MEMORY = 7,
+    ADDRESS_ARBITER = 8,
+    CPU_TIME = 9
+};
+
+using Handle = u32;
+
+struct ResourceLimits {
+    Handle handle;
+};
+
+struct ProcessData {
+    // Resource limits for this process
+    ResourceLimits limits;
+};
+
+static const char* kernelObjectTypeToString(KernelObjectType t) {
+    switch (t) {
+        case KernelObjectType::Process: return "process";
+        case KernelObjectType::ResourceLimit: return "resource limit";
+        default: return "unknown";
+    }
+}
+
+// Generic kernel object class
+struct KernelObject {
+    Handle handle = 0; // A u32 the OS will use to identify objects
+    void* data = nullptr;
+    KernelObjectType type;
+
+    KernelObject(Handle handle, KernelObjectType type) : handle(handle), type(type) {}
+
+    // 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() {}
+};

include/kernel/resource_limits.hpp

@@ -0,0 +1,2 @@
+#pragma once
+#include "kernel_types.hpp"