From b3f8cb9003752d23ed1d5698c4c920267e66b2ef Mon Sep 17 00:00:00 2001
From: Drew Galbraith <dgalbraith33@gmail.com>
Date: Thu, 18 May 2023 01:16:53 -0700
Subject: [PATCH] Dump the memory map from limine.

Also adds the ability to print formatted messages.
---
 zion/CMakeLists.txt     |   1 +
 zion/boot/boot_info.cpp |  28 +++
 zion/boot/boot_info.h   |  10 +
 zion/boot/limine.h      | 461 ++++++++++++++++++++++++++++++++++++++++
 zion/debug/debug.cpp    | 139 +++++++++++-
 zion/debug/debug.h      |   6 +-
 zion/zion.cpp           |  14 +-
 7 files changed, 644 insertions(+), 15 deletions(-)
 create mode 100644 zion/boot/boot_info.cpp
 create mode 100644 zion/boot/boot_info.h
 create mode 100644 zion/boot/limine.h

diff --git a/zion/CMakeLists.txt b/zion/CMakeLists.txt
index 3877f64..d72a17f 100644
--- a/zion/CMakeLists.txt
+++ b/zion/CMakeLists.txt
@@ -1,4 +1,5 @@
 add_executable(zion
+  boot/boot_info.cpp
   common/gdt.cpp
   common/load_gdt.s
   debug/debug.cpp
diff --git a/zion/boot/boot_info.cpp b/zion/boot/boot_info.cpp
new file mode 100644
index 0000000..6cbe2d5
--- /dev/null
+++ b/zion/boot/boot_info.cpp
@@ -0,0 +1,28 @@
+#include "boot/boot_info.h"
+
+#include "debug/debug.h"
+
+namespace boot {
+static volatile struct limine_memmap_request gMemmapRequest {
+  .id = LIMINE_MEMMAP_REQUEST, .revision = 0, .response = 0,
+};
+
+const limine_memmap_response& GetMemoryMap() {
+  if (!gMemmapRequest.response) {
+    panic("No memmap from limine.");
+  }
+  return *gMemmapRequest.response;
+}
+
+static volatile struct limine_hhdm_request gHhdmRequest {
+  .id = LIMINE_HHDM_REQUEST, .revision = 0, .response = 0,
+};
+
+uint64_t GetHigherHalfDirectMap() {
+  if (!gHhdmRequest.response) {
+    panic("No HHDM response from limine.");
+  }
+  return gHhdmRequest.response->offset;
+}
+
+}  // namespace boot
diff --git a/zion/boot/boot_info.h b/zion/boot/boot_info.h
new file mode 100644
index 0000000..4506713
--- /dev/null
+++ b/zion/boot/boot_info.h
@@ -0,0 +1,10 @@
+#pragma once
+
+#include "boot/limine.h"
+
+namespace boot {
+
+const limine_memmap_response& GetMemoryMap();
+uint64_t GetHigherHalfDirectMap();
+
+}  // namespace boot
diff --git a/zion/boot/limine.h b/zion/boot/limine.h
new file mode 100644
index 0000000..79f8faf
--- /dev/null
+++ b/zion/boot/limine.h
@@ -0,0 +1,461 @@
+// Copied from https://github.com/limine-bootloader/limine/blob/trunk/limine.h
+// TODO:
+
+#pragma once
+
+#include <stdint.h>
+
+extern "C" {
+
+/* Misc */
+
+#ifdef LIMINE_NO_POINTERS
+#define LIMINE_PTR(TYPE) uint64_t
+#else
+#define LIMINE_PTR(TYPE) TYPE
+#endif
+
+#define LIMINE_COMMON_MAGIC 0xc7b1dd30df4c8b88, 0x0a82e883a194f07b
+
+struct limine_uuid {
+  uint32_t a;
+  uint16_t b;
+  uint16_t c;
+  uint8_t d[8];
+};
+
+#define LIMINE_MEDIA_TYPE_GENERIC 0
+#define LIMINE_MEDIA_TYPE_OPTICAL 1
+#define LIMINE_MEDIA_TYPE_TFTP 2
+
+struct limine_file {
+  uint64_t revision;
+  LIMINE_PTR(void *) address;
+  uint64_t size;
+  LIMINE_PTR(char *) path;
+  LIMINE_PTR(char *) cmdline;
+  uint32_t media_type;
+  uint32_t unused;
+  uint32_t tftp_ip;
+  uint32_t tftp_port;
+  uint32_t partition_index;
+  uint32_t mbr_disk_id;
+  struct limine_uuid gpt_disk_uuid;
+  struct limine_uuid gpt_part_uuid;
+  struct limine_uuid part_uuid;
+};
+
+/* Boot info */
+
+#define LIMINE_BOOTLOADER_INFO_REQUEST \
+  { LIMINE_COMMON_MAGIC, 0xf55038d8e2a1202f, 0x279426fcf5f59740 }
+
+struct limine_bootloader_info_response {
+  uint64_t revision;
+  LIMINE_PTR(char *) name;
+  LIMINE_PTR(char *) version;
+};
+
+struct limine_bootloader_info_request {
+  uint64_t id[4];
+  uint64_t revision;
+  LIMINE_PTR(struct limine_bootloader_info_response *) response;
+};
+
+/* Stack size */
+
+#define LIMINE_STACK_SIZE_REQUEST \
+  { LIMINE_COMMON_MAGIC, 0x224ef0460a8e8926, 0xe1cb0fc25f46ea3d }
+
+struct limine_stack_size_response {
+  uint64_t revision;
+};
+
+struct limine_stack_size_request {
+  uint64_t id[4];
+  uint64_t revision;
+  LIMINE_PTR(struct limine_stack_size_response *) response;
+  uint64_t stack_size;
+};
+
+/* HHDM */
+
+#define LIMINE_HHDM_REQUEST \
+  { LIMINE_COMMON_MAGIC, 0x48dcf1cb8ad2b852, 0x63984e959a98244b }
+
+struct limine_hhdm_response {
+  uint64_t revision;
+  uint64_t offset;
+};
+
+struct limine_hhdm_request {
+  uint64_t id[4];
+  uint64_t revision;
+  LIMINE_PTR(struct limine_hhdm_response *) response;
+};
+
+/* Framebuffer */
+
+#define LIMINE_FRAMEBUFFER_REQUEST \
+  { LIMINE_COMMON_MAGIC, 0x9d5827dcd881dd75, 0xa3148604f6fab11b }
+
+#define LIMINE_FRAMEBUFFER_RGB 1
+
+struct limine_framebuffer {
+  LIMINE_PTR(void *) address;
+  uint64_t width;
+  uint64_t height;
+  uint64_t pitch;
+  uint16_t bpp;
+  uint8_t memory_model;
+  uint8_t red_mask_size;
+  uint8_t red_mask_shift;
+  uint8_t green_mask_size;
+  uint8_t green_mask_shift;
+  uint8_t blue_mask_size;
+  uint8_t blue_mask_shift;
+  uint8_t unused[7];
+  uint64_t edid_size;
+  LIMINE_PTR(void *) edid;
+};
+
+struct limine_framebuffer_response {
+  uint64_t revision;
+  uint64_t framebuffer_count;
+  LIMINE_PTR(struct limine_framebuffer **) framebuffers;
+};
+
+struct limine_framebuffer_request {
+  uint64_t id[4];
+  uint64_t revision;
+  LIMINE_PTR(struct limine_framebuffer_response *) response;
+};
+
+/* Framebuffer (legacy) */
+
+#define LIMINE_FRAMEBUFFER_LEGACY_REQUEST \
+  { LIMINE_COMMON_MAGIC, 0xcbfe81d7dd2d1977, 0x063150319ebc9b71 }
+
+struct limine_framebuffer_legacy {
+  LIMINE_PTR(void *) address;
+  uint16_t width;
+  uint16_t height;
+  uint16_t pitch;
+  uint16_t bpp;
+  uint8_t memory_model;
+  uint8_t red_mask_size;
+  uint8_t red_mask_shift;
+  uint8_t green_mask_size;
+  uint8_t green_mask_shift;
+  uint8_t blue_mask_size;
+  uint8_t blue_mask_shift;
+  uint8_t unused;
+  uint64_t edid_size;
+  LIMINE_PTR(void *) edid;
+};
+
+struct limine_framebuffer_legacy_response {
+  uint64_t revision;
+  uint64_t framebuffer_count;
+  LIMINE_PTR(struct limine_framebuffer_legacy **) framebuffers;
+};
+
+struct limine_framebuffer_legacy_request {
+  uint64_t id[4];
+  uint64_t revision;
+  LIMINE_PTR(struct limine_framebuffer_legacy_response *) response;
+};
+
+/* Terminal */
+
+#define LIMINE_TERMINAL_REQUEST \
+  { LIMINE_COMMON_MAGIC, 0xc8ac59310c2b0844, 0xa68d0c7265d38878 }
+
+#define LIMINE_TERMINAL_CB_DEC 10
+#define LIMINE_TERMINAL_CB_BELL 20
+#define LIMINE_TERMINAL_CB_PRIVATE_ID 30
+#define LIMINE_TERMINAL_CB_STATUS_REPORT 40
+#define LIMINE_TERMINAL_CB_POS_REPORT 50
+#define LIMINE_TERMINAL_CB_KBD_LEDS 60
+#define LIMINE_TERMINAL_CB_MODE 70
+#define LIMINE_TERMINAL_CB_LINUX 80
+
+#define LIMINE_TERMINAL_CTX_SIZE ((uint64_t)(-1))
+#define LIMINE_TERMINAL_CTX_SAVE ((uint64_t)(-2))
+#define LIMINE_TERMINAL_CTX_RESTORE ((uint64_t)(-3))
+#define LIMINE_TERMINAL_FULL_REFRESH ((uint64_t)(-4))
+
+struct limine_terminal;
+
+typedef void (*limine_terminal_write)(struct limine_terminal *, const char *,
+                                      uint64_t);
+typedef void (*limine_terminal_callback)(struct limine_terminal *, uint64_t,
+                                         uint64_t, uint64_t, uint64_t);
+
+struct limine_terminal {
+  uint64_t columns;
+  uint64_t rows;
+  LIMINE_PTR(struct limine_framebuffer *) framebuffer;
+};
+
+struct limine_terminal_response {
+  uint64_t revision;
+  uint64_t terminal_count;
+  LIMINE_PTR(struct limine_terminal **) terminals;
+  LIMINE_PTR(limine_terminal_write) write;
+};
+
+struct limine_terminal_request {
+  uint64_t id[4];
+  uint64_t revision;
+  LIMINE_PTR(struct limine_terminal_response *) response;
+  LIMINE_PTR(limine_terminal_callback) callback;
+};
+
+/* Terminal (legacy) */
+
+#define LIMINE_TERMINAL_LEGACY_REQUEST \
+  { LIMINE_COMMON_MAGIC, 0x0785a0aea5d0750f, 0x1c1936fee0d6cf6e }
+
+struct limine_terminal_legacy;
+
+typedef void (*limine_terminal_legacy_write)(struct limine_terminal_legacy *,
+                                             const char *, uint64_t);
+typedef void (*limine_terminal_legacy_callback)(struct limine_terminal_legacy *,
+                                                uint64_t, uint64_t, uint64_t,
+                                                uint64_t);
+
+struct limine_terminal_legacy {
+  uint32_t columns;
+  uint32_t rows;
+  LIMINE_PTR(struct limine_framebuffer_legacy *) framebuffer;
+};
+
+struct limine_terminal_legacy_response {
+  uint64_t revision;
+  uint64_t terminal_count;
+  LIMINE_PTR(struct limine_terminal_legacy **) terminals;
+  LIMINE_PTR(limine_terminal_legacy_write) write;
+};
+
+struct limine_terminal_legacy_request {
+  uint64_t id[4];
+  uint64_t revision;
+  LIMINE_PTR(struct limine_terminal_legacy_response *) response;
+  LIMINE_PTR(limine_terminal_legacy_callback) callback;
+};
+
+/* 5-level paging */
+
+#define LIMINE_5_LEVEL_PAGING_REQUEST \
+  { LIMINE_COMMON_MAGIC, 0x94469551da9b3192, 0xebe5e86db7382888 }
+
+struct limine_5_level_paging_response {
+  uint64_t revision;
+};
+
+struct limine_5_level_paging_request {
+  uint64_t id[4];
+  uint64_t revision;
+  LIMINE_PTR(struct limine_5_level_paging_response *) response;
+};
+
+/* SMP */
+
+#define LIMINE_SMP_REQUEST \
+  { LIMINE_COMMON_MAGIC, 0x95a67b819a1b857e, 0xa0b61b723b6a73e0 }
+
+#define LIMINE_SMP_X2APIC (1 << 0)
+
+struct limine_smp_info;
+
+typedef void (*limine_goto_address)(struct limine_smp_info *);
+
+struct limine_smp_info {
+  uint32_t processor_id;
+  uint32_t lapic_id;
+  uint64_t reserved;
+  LIMINE_PTR(limine_goto_address) goto_address;
+  uint64_t extra_argument;
+};
+
+struct limine_smp_response {
+  uint64_t revision;
+  uint32_t flags;
+  uint32_t bsp_lapic_id;
+  uint64_t cpu_count;
+  LIMINE_PTR(struct limine_smp_info **) cpus;
+};
+
+struct limine_smp_request {
+  uint64_t id[4];
+  uint64_t revision;
+  LIMINE_PTR(struct limine_smp_response *) response;
+  uint64_t flags;
+};
+
+/* Memory map */
+
+#define LIMINE_MEMMAP_REQUEST \
+  { LIMINE_COMMON_MAGIC, 0x67cf3d9d378a806f, 0xe304acdfc50c3c62 }
+
+#define LIMINE_MEMMAP_USABLE 0
+#define LIMINE_MEMMAP_RESERVED 1
+#define LIMINE_MEMMAP_ACPI_RECLAIMABLE 2
+#define LIMINE_MEMMAP_ACPI_NVS 3
+#define LIMINE_MEMMAP_BAD_MEMORY 4
+#define LIMINE_MEMMAP_BOOTLOADER_RECLAIMABLE 5
+#define LIMINE_MEMMAP_KERNEL_AND_MODULES 6
+#define LIMINE_MEMMAP_FRAMEBUFFER 7
+
+struct limine_memmap_entry {
+  uint64_t base;
+  uint64_t length;
+  uint64_t type;
+};
+
+struct limine_memmap_response {
+  uint64_t revision;
+  uint64_t entry_count;
+  LIMINE_PTR(struct limine_memmap_entry **) entries;
+};
+
+struct limine_memmap_request {
+  uint64_t id[4];
+  uint64_t revision;
+  LIMINE_PTR(struct limine_memmap_response *) response;
+};
+
+/* Entry point */
+
+#define LIMINE_ENTRY_POINT_REQUEST \
+  { LIMINE_COMMON_MAGIC, 0x13d86c035a1cd3e1, 0x2b0caa89d8f3026a }
+
+typedef void (*limine_entry_point)(void);
+
+struct limine_entry_point_response {
+  uint64_t revision;
+};
+
+struct limine_entry_point_request {
+  uint64_t id[4];
+  uint64_t revision;
+  LIMINE_PTR(struct limine_entry_point_response *) response;
+  LIMINE_PTR(limine_entry_point) entry;
+};
+
+/* Kernel File */
+
+#define LIMINE_KERNEL_FILE_REQUEST \
+  { LIMINE_COMMON_MAGIC, 0xad97e90e83f1ed67, 0x31eb5d1c5ff23b69 }
+
+struct limine_kernel_file_response {
+  uint64_t revision;
+  LIMINE_PTR(struct limine_file *) kernel_file;
+};
+
+struct limine_kernel_file_request {
+  uint64_t id[4];
+  uint64_t revision;
+  LIMINE_PTR(struct limine_kernel_file_response *) response;
+};
+
+/* Module */
+
+#define LIMINE_MODULE_REQUEST \
+  { LIMINE_COMMON_MAGIC, 0x3e7e279702be32af, 0xca1c4f3bd1280cee }
+
+struct limine_module_response {
+  uint64_t revision;
+  uint64_t module_count;
+  LIMINE_PTR(struct limine_file **) modules;
+};
+
+struct limine_module_request {
+  uint64_t id[4];
+  uint64_t revision;
+  LIMINE_PTR(struct limine_module_response *) response;
+};
+
+/* RSDP */
+
+#define LIMINE_RSDP_REQUEST \
+  { LIMINE_COMMON_MAGIC, 0xc5e77b6b397e7b43, 0x27637845accdcf3c }
+
+struct limine_rsdp_response {
+  uint64_t revision;
+  LIMINE_PTR(void *) address;
+};
+
+struct limine_rsdp_request {
+  uint64_t id[4];
+  uint64_t revision;
+  LIMINE_PTR(struct limine_rsdp_response *) response;
+};
+
+/* SMBIOS */
+
+#define LIMINE_SMBIOS_REQUEST \
+  { LIMINE_COMMON_MAGIC, 0x9e9046f11e095391, 0xaa4a520fefbde5ee }
+
+struct limine_smbios_response {
+  uint64_t revision;
+  LIMINE_PTR(void *) entry_32;
+  LIMINE_PTR(void *) entry_64;
+};
+
+struct limine_smbios_request {
+  uint64_t id[4];
+  uint64_t revision;
+  LIMINE_PTR(struct limine_smbios_response *) response;
+};
+
+/* EFI system table */
+
+#define LIMINE_EFI_SYSTEM_TABLE_REQUEST \
+  { LIMINE_COMMON_MAGIC, 0x5ceba5163eaaf6d6, 0x0a6981610cf65fcc }
+
+struct limine_efi_system_table_response {
+  uint64_t revision;
+  LIMINE_PTR(void *) address;
+};
+
+struct limine_efi_system_table_request {
+  uint64_t id[4];
+  uint64_t revision;
+  LIMINE_PTR(struct limine_efi_system_table_response *) response;
+};
+
+/* Boot time */
+
+#define LIMINE_BOOT_TIME_REQUEST \
+  { LIMINE_COMMON_MAGIC, 0x502746e184c088aa, 0xfbc5ec83e6327893 }
+
+struct limine_boot_time_response {
+  uint64_t revision;
+  int64_t boot_time;
+};
+
+struct limine_boot_time_request {
+  uint64_t id[4];
+  uint64_t revision;
+  LIMINE_PTR(struct limine_boot_time_response *) response;
+};
+
+/* Kernel address */
+
+#define LIMINE_KERNEL_ADDRESS_REQUEST \
+  { LIMINE_COMMON_MAGIC, 0x71ba76863cc55f63, 0xb2644a48c516a487 }
+
+struct limine_kernel_address_response {
+  uint64_t revision;
+  uint64_t physical_base;
+  uint64_t virtual_base;
+};
+
+struct limine_kernel_address_request {
+  uint64_t id[4];
+  uint64_t revision;
+  LIMINE_PTR(struct limine_kernel_address_response *) response;
+};
+}
diff --git a/zion/debug/debug.cpp b/zion/debug/debug.cpp
index 406594f..fdd52d5 100644
--- a/zion/debug/debug.cpp
+++ b/zion/debug/debug.cpp
@@ -4,17 +4,140 @@
 
 #define COM1 0x3f8
 
-void dbgln(const char* str) {
-  while (*str != 0) {
-    outb(COM1, *str);
-    str++;
-  }
-  outb(COM1, '\n');
+namespace {
+bool is_transmit_empty() { return (inb(COM1 + 5) & 0x20) != 0; }
+
+void dbgputchar(char c) {
+  while (!is_transmit_empty())
+    ;
+
+  outb(COM1, c);
 }
 
-void panic(const char* str) {
+void dbgcstr(const char* str) {
+  for (; *str != '\0'; str++) {
+    dbgputchar(*str);
+  }
+}
+
+void U64ToStr(uint64_t u, char* str) {
+  uint64_t len = 0;
+  uint64_t u2 = u;
+  while (u2 != 0) {
+    len++;
+    u2 /= 10;
+  }
+
+  if (len == 0) {
+    len = 1;
+  }
+
+  str[len] = '\0';
+
+  for (int64_t i = len - 1; i >= 0; i--) {
+    str[i] = (u % 10) + '0';
+    u /= 10;
+  }
+}
+
+void HexToStr(uint64_t u, char* str) {
+  uint64_t len = 0;
+  uint64_t u2 = u;
+  while (u2 != 0) {
+    len++;
+    u2 /= 16;
+  }
+
+  if (len == 0) {
+    len = 1;
+  }
+
+  len += 2;
+  str[0] = '0';
+  str[1] = 'x';
+  str[len] = '\0';
+  const char* hex = "0123456789ABCDEF";
+  for (uint64_t i = len - 1; i > 1; i--) {
+    str[i] = hex[u & 0xF];
+    u >>= 4;
+  }
+}
+
+void MemToStr(uint64_t u, char* str) {
+  str[0] = '0';
+  str[1] = 'x';
+  const char* hex = "0123456789ABCDEF";
+  for (uint64_t i = 0; i < 16; i++) {
+    str[17 - i] = hex[(u >> (i * 4)) & 0xF];
+  }
+  str[18] = '\0';
+}
+
+void dbgln_internal(const char* fmt, va_list args) {
+  for (; *fmt != '\0'; fmt++) {
+    if (*fmt != '%') {
+      dbgputchar(*fmt);
+      continue;
+    }
+    fmt++;
+    switch (*fmt) {
+      case '%':
+        dbgputchar('%');
+        break;
+      case 's': {
+        char* str = va_arg(args, char*);
+        dbgcstr(str);
+        break;
+      }
+      case 'c': {
+        char c = va_arg(args, int);
+        dbgputchar(c);
+        break;
+      }
+      case 'u': {
+        uint64_t u = va_arg(args, uint64_t);
+        char str[21];
+        U64ToStr(u, str);
+        dbgcstr(str);
+        break;
+      }
+      case 'x': {
+        uint64_t u = va_arg(args, uint64_t);
+        char str[19];
+        HexToStr(u, str);
+        dbgcstr(str);
+        break;
+      }
+      case 'm': {
+        uint64_t u = va_arg(args, uint64_t);
+        char str[19];
+        MemToStr(u, str);
+        dbgcstr(str);
+        break;
+      }
+      default: {
+        panic("Bad format char: %c", *fmt);
+      }
+    }
+  }
+  dbgputchar('\n');
+}
+
+}  // namespace
+
+void dbgln(const char* fmt, ...) {
+  va_list arg;
+  va_start(arg, fmt);
+  dbgln_internal(fmt, arg);
+  va_end(arg);
+}
+
+void panic(const char* fmt, ...) {
   asm volatile("cli");
-  dbgln(str);
+  va_list arg;
+  va_start(arg, fmt);
+  dbgln_internal(fmt, arg);
+  va_end(arg);
   dbgln("PANIC");
   while (1)
     ;
diff --git a/zion/debug/debug.h b/zion/debug/debug.h
index 77341da..713908f 100644
--- a/zion/debug/debug.h
+++ b/zion/debug/debug.h
@@ -1,4 +1,6 @@
 #pragma once
 
-void dbgln(const char* str);
-void panic(const char* str);
+#include <stdarg.h>
+
+void dbgln(const char* str, ...);
+void panic(const char* str, ...);
diff --git a/zion/zion.cpp b/zion/zion.cpp
index fe44dfc..12ffa8b 100644
--- a/zion/zion.cpp
+++ b/zion/zion.cpp
@@ -1,17 +1,21 @@
 #include <stdint.h>
 
+#include "boot/boot_info.h"
+#include "boot/limine.h"
 #include "common/gdt.h"
 #include "debug/debug.h"
 #include "interrupt/interrupt.h"
 
 extern "C" void zion() {
-  dbgln("Hello World!");
   InitGdt();
-  dbgln("New GDT Loaded!");
   InitIdt();
-  dbgln("IDT Loaded!");
-  uint64_t a = 11 / 0;
-  dbgln("Recovered");
+
+  const limine_memmap_response& resp = boot::GetMemoryMap();
+  dbgln("Base,Length,Type");
+  for (uint64_t i = 0; i < resp.entry_count; i++) {
+    const limine_memmap_entry& entry = *resp.entries[i];
+    dbgln("%m,%x,%u", entry.base, entry.length, entry.type);
+  }
 
   while (1)
     ;