Manage KernelStacks separately rather than just allocing bytes.

Create a global KernelStackManager that will handle the relevant allocs.

zion/memory/kernel_stack_manager.cpp

@@ -0,0 +1,31 @@
+#include "memory/kernel_stack_manager.h"
+
+#include "debug/debug.h"
+#include "memory/paging_util.h"
+
+#define KERNEL_STACK_START 0xFFFFFFFF'90000000
+#define KERNEL_STACK_LIMIT 0xFFFFFFFF'9FFFFFFF
+#define KERNEL_STACK_OFFSET 0x4000
+
+KernelStackManager* gKernelStackManager;
+
+void KernelStackManager::Init() {
+  gKernelStackManager = new KernelStackManager();
+}
+
+KernelStackManager::KernelStackManager()
+    : next_stack_addr_(KERNEL_STACK_START) {}
+
+uint64_t* KernelStackManager::AllocateKernelStack() {
+  next_stack_addr_ += KERNEL_STACK_OFFSET;
+  if (next_stack_addr_ >= KERNEL_STACK_LIMIT) {
+    panic("No more kernelstack space");
+  }
+  EnsureResident(next_stack_addr_ - 0x3000, 0x3000);
+  return reinterpret_cast<uint64_t*>(next_stack_addr_) - 1;
+}
+
+void KernelStackManager::FreeKernelStack(uint64_t stack_base) {
+  freed_stack_cnt_++;
+  dbgln("Freed kernel stacks using %u KiB", freed_stack_cnt_ * 12);
+}

zion/memory/kernel_stack_manager.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <stdint.h>
+
+// KernelStackManager doles out kernel stacks.
+//
+// KernelStacks are in the region:
+// 0xFFFFFFFF 90000000 - 0xFFFFFFFF 9FFFFFFF
+//
+// Each kernel stack is 12 KiB with a 4 Kib page boundary.
+//
+// It is  global object that is only exposed via internal linkage
+// to the VirtualMemory class. All kernel stacks should be created through that
+// class.
+class KernelStackManager {
+ public:
+  static void Init();
+
+  uint64_t* AllocateKernelStack();
+
+  void FreeKernelStack(uint64_t stack_base);
+
+ private:
+  KernelStackManager();
+  uint64_t next_stack_addr_;
+  uint64_t freed_stack_cnt_ = 0;
+};

zion/memory/virtual_memory.cpp

@@ -0,0 +1,18 @@
+#include "memory/virtual_memory.h"
+
+#include "memory/kernel_stack_manager.h"
+
+extern KernelStackManager* gKernelStackManager;
+
+uint64_t* VirtualMemory::AllocateKernelStack() {
+  return gKernelStackManager->AllocateKernelStack();
+}
+
+uint64_t VirtualMemory::GetNextMemMapAddr(uint64_t size) {
+  uint64_t addr = next_memmap_addr_;
+  next_memmap_addr_ += size;
+  if (next_memmap_addr_ >= 0x30'00000000) {
+    panic("OOM: Memmap");
+  }
+  return addr;
+}

zion/memory/virtual_memory.h

@@ -42,14 +42,10 @@ class VirtualMemory {
   VirtualMemory(const VirtualMemory&) = delete;
   VirtualMemory(VirtualMemory&&) = delete;
 
-  uint64_t GetNextMemMapAddr(uint64_t size) {
-    uint64_t addr = next_memmap_addr_;
-    next_memmap_addr_ += size;
-    if (next_memmap_addr_ >= 0x30'00000000) {
-      panic("OOM: Memmap");
-    }
-    return addr;
-  }
+  uint64_t GetNextMemMapAddr(uint64_t size);
+
+  // Kernel
+  uint64_t* AllocateKernelStack();
 
  private:
   uint64_t cr3_ = 0;