fix: make pmm works for x86_64 + panic$

meta/plugins/cli.py

@@ -45,8 +45,8 @@ def _(args: StartArgs):
                     # "-enable-kvm",
                     "-no-reboot",
                     "-no-shutdown",
-                    # "-display",
+                    "-display",
-                    # "none",
+                    "none",
                     "-smp",
                     "4",
                     "-serial",

src/kernel/hal/rv32/paging.c

@@ -97,8 +97,7 @@ void hal_switch_space(HalPage space) {
 void paging_init(void) {
     PhysObj page_phys = pmm_alloc(page_size());
     if (page_phys.base == 0) {
-        error$("Couldn't allocate page table");
+        panic$("Couldn't allocate page table");
-        hal_brkpoint();
     }
 
     memset((void*)page_phys.base, 0, page_size());
@@ -108,32 +107,28 @@ void paging_init(void) {
     size_t text_end     = align_up$((uintptr_t)text_end_addr, page_size());
     HalMappingError err = hal_map_page((HalPage){kernel_page_table}, text_start, text_start, text_end - text_start, HAL_MAP_READ | HAL_MAP_EXEC);
     if (err != HAL_MAP_OK) {
-        error$("Couldn't map kernel text, cause: %s", HalMappingErrorString(err));
+        panic$("Couldn't map kernel text, cause: %s", HalMappingErrorString(err));
-        hal_brkpoint();
     }
 
     size_t rodata_start = align_down$((uintptr_t)rodata_start_addr, page_size());
     size_t rodata_end   = align_up$((uintptr_t)rodata_end_addr, page_size());
     err                 = hal_map_page((HalPage){kernel_page_table}, rodata_start, rodata_start, rodata_end - rodata_start, HAL_MAP_READ);
     if (err != HAL_MAP_OK) {
-        error$("Couldn't map kernel rodata, cause: %s", HalMappingErrorString(err));
+        panic$("Couldn't map kernel rodata, cause: %s", HalMappingErrorString(err));
-        hal_brkpoint();
     }
 
     size_t data_start = align_down$((uintptr_t)data_start_addr, page_size());
     size_t data_end   = align_up$((uintptr_t)data_end_addr, page_size());
     err               = hal_map_page((HalPage){kernel_page_table}, data_start, data_start, data_end - data_start, HAL_MAP_READ | HAL_MAP_WRITE);
     if (err != HAL_MAP_OK) {
-        error$("Couldn't map kernel data, cause: %s", HalMappingErrorString(err));
+        panic$("Couldn't map kernel data, cause: %s", HalMappingErrorString(err));
-        hal_brkpoint();
     }
 
     size_t stack_start = align_down$((uintptr_t)__stack_top - kib$(128), page_size());
     size_t stack_end   = align_up$((uintptr_t)__stack_top, page_size());
     err                = hal_map_page((HalPage){kernel_page_table}, stack_start, stack_start, stack_end - stack_start, HAL_MAP_READ | HAL_MAP_WRITE);
     if (err != HAL_MAP_OK) {
-        error$("Couldn't map kernel stack, cause: %s", HalMappingErrorString(err));
+        panic$("Couldn't map kernel stack, cause: %s", HalMappingErrorString(err));
-        hal_brkpoint();
     }
 
     HandoverRecord rec;

src/kernel/hal/x86_64/boot.c

@@ -1,6 +1,7 @@
 #include <dtb>
 #include <limine>
 #include <logger>
+#include <pmm>
 
 __attribute__((used, section(".limine_requests"))) static volatile LIMINE_BASE_REVISION(3);
 __attribute__((used, section(".limine_requests_start"))) static volatile LIMINE_REQUESTS_START_MARKER;
@@ -9,8 +10,8 @@ __attribute__((used, section(".limine_requests_end"))) static volatile LIMINE_RE
 void kmain(void);
 
 void x86_64_start(void) {
-    info$("Hello, x86_64 !");
+    pmm_init();
-    // kmain();
+    kmain();
 }
 
 DTBNode* hal_dtb_root(void) {

src/kernel/libs/handover-limine/mod.c

@@ -0,0 +1,93 @@
+#include <helpers/mem.h>
+#include <limine>
+#include <logger>
+#include <stdint.h>
+
+#include "limine/mod.h"
+#include "mod.h"
+
+/* --- Handover ------------------------------------------------------------- */
+
+static uint8_t handover_buffer[kib$(16)] = {0};
+static HandoverPayload* payload          = NULL;
+
+/* --- Limine requests ------------------------------------------------------ */
+
+__attribute__((used, section(".limine_requests"))) static volatile struct limine_memmap_request mmap_req = {
+    .id       = LIMINE_MEMMAP_REQUEST,
+    .revision = 0
+};
+
+static void handover_parse_mmap(HandoverPayload* self) {
+    if (mmap_req.response == NULL) [[clang::unlikely]] {
+        panic$("Couldn't get limine's memory maps");
+    }
+
+    info$("Retrieved memory map from Limine");
+
+    info$("======================================================");
+    info$("    TYPE     |       BASE         |       LIMIT       ");
+    info$("======================================================");
+
+    for (size_t i = 0; i < mmap_req.response->entry_count; i++) {
+        struct limine_memmap_entry* entry = mmap_req.response->entries[i];
+        HandoverRecord record             = {0};
+
+        switch (entry->type) {
+        case LIMINE_MEMMAP_USABLE: {
+            info$("  FREE         | %p | %p", entry->base, entry->base + entry->length);
+            record.tag = HANDOVER_FREE;
+            break;
+        }
+
+        case LIMINE_MEMMAP_ACPI_NVS:
+        case LIMINE_MEMMAP_RESERVED:
+        case LIMINE_MEMMAP_BAD_MEMORY: {
+            info$("  RESERVED     | %p | %p", entry->base, entry->base + entry->length);
+            record.tag = HANDOVER_RESERVED;
+            break;
+        }
+
+        case LIMINE_MEMMAP_ACPI_RECLAIMABLE:
+        case LIMINE_MEMMAP_BOOTLOADER_RECLAIMABLE: {
+            info$("  RECLAIMABLE  | %p | %p", entry->base, entry->base + entry->length);
+            record.tag = HANDOVER_LOADER;
+            break;
+        }
+
+        case LIMINE_MEMMAP_KERNEL_AND_MODULES: {
+            info$("  MODULE       | %p | %p", entry->base, entry->base + entry->length);
+            record.tag = HANDOVER_KERNEL;
+            break;
+        }
+
+        case LIMINE_MEMMAP_FRAMEBUFFER: {
+            info$("  FRAMEBUFFER  | %p | %p", entry->base, entry->base + entry->length);
+            record.tag = HANDOVER_FB;
+            break;
+        }
+
+        default:
+            [[clang::unlikely]] {
+                panic$("Unknown memory map entry type %d", entry->type);
+            }
+        }
+
+        record.start = entry->base;
+        record.size  = entry->length;
+
+        handover_append(self, record);
+    }
+
+    info$("=====================================================");
+}
+
+HandoverPayload* handover(void) {
+    if (payload == NULL) {
+        payload       = (HandoverPayload*)handover_buffer;
+        payload->size = kib$(16);
+        handover_parse_mmap(payload);
+    }
+
+    return payload;
+}

src/kernel/pmm/mod.c

@@ -50,7 +50,7 @@ void pmm_init(void) {
     handover_foreach_record(hand, record) {
         if (record.tag == HANDOVER_FREE && record.size >= bitmap.len) {
             debug$("Bitmap base: %p", record.start);
-            bitmap.bitmap = (uint8_t*)record.start;
+            bitmap.bitmap = (uint8_t*)hal_mmap_l2h(record.start);
 
             handover_append(handover(), (HandoverRecord){
                                             .tag   = HANDOVER_RESERVED,
@@ -65,8 +65,7 @@ void pmm_init(void) {
     }
 
     if (bitmap.bitmap == NULL) {
-        error$("Couldn't allocate bitmap");
+        panic$("Couldn't allocate bitmap");
-        hal_brkpoint();
     }
 
     memset(bitmap.bitmap, 0xFF, bitmap.len);
@@ -108,8 +107,7 @@ PhysObj pmm_alloc(size_t len) {
         bitmap.last = 0;
         return pmm_alloc(pages);
     } else {
-        error$("Out of physical memory");
+        panic$("Out of physical memory");
-        hal_brkpoint();
     }
     __builtin_unreachable();
 }

src/libs/handover/limine/mod.c

@@ -1,8 +0,0 @@
-#include "mod.h"
-#include <limine>
-
-static HandoverPayload* payload = NULL;
-
-HandoverPayload* handover(void) {
-    return payload;
-}