feat: add paging support

Author: viktorpopp

kernel/src/arch/x86/include/arch/paging.h

@@ -0,0 +1,44 @@
+/*
+ * Zeronix - A Minimal Kernel
+ * Copyright (C) 2024-present Viktor Popp and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+#include "limine/limine.h"
+#include <stdint.h>
+
+#define PMLE_PRESENT        1
+#define PMLE_WRITE          (1 << 1)
+#define PMLE_NOT_EXECUTABLE (1ull << 63)
+
+extern uint64_t get_pml4();
+extern uint64_t load_pml4(uint64_t *pml4);
+
+#define PMLT_MASK 0x1ff
+
+#define PML4_INDEX(a) ((a >> 39) & PMLT_MASK)
+#define PML3_INDEX(a) ((a >> 30) & PMLT_MASK)
+#define PML2_INDEX(a) ((a >> 21) & PMLT_MASK)
+#define PML1_INDEX(a) ((a >> 12) & PMLT_MASK)
+
+#define PAGE_ADDR_MASK   0xFFFFFFFFFFFFF000ULL
+#define PAGE_GET_ADDR(a) ((a) & PAGE_ADDR_MASK)
+
+void paging_init(volatile struct limine_memmap_request *memmap_request);
+
+void paging_map_region(uint64_t *pml4, uint64_t phys_start, uint64_t virt_start, uint64_t len,
+                       uint64_t flags);
+void paging_unmap_region(uint64_t *pml4, uint64_t virt_start, uint64_t len);

kernel/src/arch/x86/paging.asm

@@ -0,0 +1,25 @@
+; Zeronix - A Minimal Kernel
+; Copyright (C) 2024-present Viktor Popp and contributors
+;
+; This program is free software: you can redistribute it and/or modify
+; it under the terms of the GNU General Public License as published by
+; the Free Software Foundation, either version 3 of the License, or
+; (at your option) any later version.
+;
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+;
+; You should have received a copy of the GNU General Public License
+; along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+global get_pml4
+get_pml4:
+    mov rax, cr3
+    ret
+
+global load_pml4
+load_pml4:
+	mov cr3, rdi
+	ret

kernel/src/arch/x86/paging.c

@@ -0,0 +1,180 @@
+/*
+ * Zeronix - A Minimal Kernel
+ * Copyright (C) 2024-present Viktor Popp and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+#include "arch/paging.h"
+#include "core/panic.h"
+#include "lib/align.h"
+#include "limine/limine.h"
+#include "mem/mmutil.h"
+#include "mem/pmm.h"
+#include "util/log.h"
+#include <stdint.h>
+#include <string.h>
+
+uint64_t *global_kernel_pml4;
+
+void _unmap(uint64_t *pml4, uint64_t virt);
+void _map(uint64_t *pml4, uint64_t phys, uint64_t virt, uint64_t flags);
+uint64_t *_get_or_create_pmlt(uint64_t *pmlt, uint64_t pmlt_idx, uint64_t flags);
+uint64_t *_get_pmlt(uint64_t *pmlt, uint64_t pmlt_idx);
+
+void paging_init(volatile struct limine_memmap_request *memmap_request)
+{
+    uint64_t *kernel_pml4 = HIGHER_HALF(palloc(1));
+
+    log_trace("Limine's PML4 sits at: 0x%llx", get_pml4());
+    log_trace("__kernel_start:\t 0x%p", &__kernel_start);
+    log_trace("__kernel_text:\t 0x%p -> 0x%p", &__kernel_text_start, &__kernel_text_end);
+    log_trace("__kernel_data:\t 0x%p -> 0x%p", &__kernel_data_start, &__kernel_data_end);
+    log_trace("__kernel_rodata:\t 0x%p -> 0x%p", &__kernel_rodata_start, &__kernel_rodata_end);
+    log_trace("__limine_requests: 0x%p -> 0x%p", &__limine_requests_start, &__limine_requests_end);
+    log_trace("__kernel_end:\t 0x%p", &__kernel_end);
+
+    uint64_t text_len = (uint64_t)&__kernel_text_end - (uint64_t)&__kernel_text_start;
+    paging_map_region(kernel_pml4, (uint64_t)&__kernel_text_start - VIRT_BASE + PHYS_BASE,
+                      (uint64_t)&__kernel_text_start, text_len, PMLE_PRESENT | PMLE_WRITE);
+
+    uint64_t rodata_len = (uint64_t)&__kernel_rodata_end - (uint64_t)&__kernel_rodata_start;
+    paging_map_region(kernel_pml4, (uint64_t)&__kernel_rodata_start - VIRT_BASE + PHYS_BASE,
+                      (uint64_t)&__kernel_rodata_start, rodata_len,
+                      PMLE_PRESENT | PMLE_NOT_EXECUTABLE);
+
+    // map the .data section and everything else
+    uint64_t data_len  = (uint64_t)&__kernel_data_end - (uint64_t)&__kernel_data_start;
+    uint64_t other_len = (uint64_t)&__kernel_end - (uint64_t)&__kernel_data_end;
+    paging_map_region(kernel_pml4, (uint64_t)&__kernel_data_start - VIRT_BASE + PHYS_BASE,
+                      (uint64_t)&__kernel_data_start, data_len + other_len,
+                      PMLE_PRESENT | PMLE_WRITE | PMLE_NOT_EXECUTABLE);
+
+    uint64_t reqs_len = (uint64_t)&__limine_requests_end - (uint64_t)&__limine_requests_start;
+    paging_map_region(kernel_pml4, (uint64_t)&__limine_requests_start - VIRT_BASE + PHYS_BASE,
+                      (uint64_t)&__limine_requests_start, reqs_len,
+                      PMLE_PRESENT | PMLE_WRITE | PMLE_NOT_EXECUTABLE);
+
+    // map the higher half
+    for (uint64_t i = 0; i < memmap_request->response->entry_count; i++)
+    {
+        struct limine_memmap_entry *e = memmap_request->response->entries[i];
+        paging_map_region(kernel_pml4, e->base, (uint64_t)HIGHER_HALF(e->base), e->length,
+                          PMLE_PRESENT | PMLE_WRITE);
+    }
+
+    log_debug("Zinix PML4 sits at: 0x%llp", kernel_pml4);
+    global_kernel_pml4 = (uint64_t *)PHYSICAL(kernel_pml4);
+    load_pml4(global_kernel_pml4);
+    log_info("Initialized Paging");
+}
+
+void paging_map_region(uint64_t *pml4, uint64_t phys_start, uint64_t virt_start, uint64_t len,
+                       uint64_t flags)
+{
+    uint64_t pages = ALIGN_UP(len, FRAME_SIZE) / FRAME_SIZE;
+    for (uint64_t i = 0; i < pages; i++)
+    {
+        uint64_t phys = phys_start + (i * FRAME_SIZE);
+        uint64_t virt = virt_start + (i * FRAME_SIZE);
+        _map(pml4, phys, virt, flags);
+    }
+}
+
+void paging_unmap_region(uint64_t *pml4, uint64_t virt_start, uint64_t len)
+{
+    uint64_t pages = ALIGN_UP(len, FRAME_SIZE) / FRAME_SIZE;
+    for (uint64_t i = 0; i < pages; i++)
+    {
+        uint64_t virt = virt_start + (i * FRAME_SIZE);
+        _unmap(pml4, virt);
+    }
+}
+
+void _map(uint64_t *pml4, uint64_t phys, uint64_t virt, uint64_t flags)
+{
+    uint64_t pml4_idx = PML4_INDEX(virt);
+    uint64_t pml3_idx = PML3_INDEX(virt);
+    uint64_t pml2_idx = PML2_INDEX(virt);
+    uint64_t pml1_idx = PML1_INDEX(virt);
+
+    uint64_t *pml3 = _get_or_create_pmlt(pml4, pml4_idx, flags);
+    uint64_t *pml2 = _get_or_create_pmlt(pml3, pml3_idx, flags);
+    uint64_t *pml1 = _get_or_create_pmlt(pml2, pml2_idx, flags);
+
+    // finally set the the phys addr in the pml1
+    pml1[pml1_idx] = PAGE_GET_ADDR(phys) | flags;
+
+    // invalidate the virtual address
+    __asm__ volatile("invlpg (%0)" : : "r"(virt) : "memory");
+}
+
+void _unmap(uint64_t *pml4, uint64_t virt)
+{
+    uint64_t pml4_idx = PML4_INDEX(virt);
+    uint64_t pml3_idx = PML3_INDEX(virt);
+    uint64_t pml2_idx = PML2_INDEX(virt);
+    uint64_t pml1_idx = PML1_INDEX(virt);
+
+    uint64_t *pml3 = _get_pmlt(pml4, pml4_idx);
+    uint64_t *pml2 = _get_pmlt(pml3, pml3_idx);
+    uint64_t *pml1 = _get_pmlt(pml2, pml2_idx);
+
+    pml1[pml1_idx] = 0;
+
+    // invalidate the virtual address
+    __asm__ volatile("invlpg (%0)" : : "r"(virt) : "memory");
+}
+
+uint64_t *_get_or_create_pmlt(uint64_t *pmlt, uint64_t pmlt_idx, uint64_t flags)
+{
+    bool newly_created = false;
+
+    // if the pmlt and pmlt_idx hasn't isn't present allocate it
+    if (!(pmlt[pmlt_idx] && PMLE_PRESENT))
+    {
+        pmlt[pmlt_idx] = (uint64_t)palloc(1) | flags;
+        newly_created  = true;
+    }
+
+    // get the physical address of the next pmlt
+    uint64_t page_addr = PAGE_GET_ADDR(pmlt[pmlt_idx]);
+
+    if (!page_addr)
+    {
+        panic(NULL, "failed to allocate space for new PMLT");
+    }
+
+    // convert it to a virtual address
+    uint64_t *table_vaddr = (uint64_t *)HIGHER_HALF(page_addr);
+
+    // if the next pmlt is newly created zero it
+    if (newly_created)
+    {
+        memset(table_vaddr, 0x00, FRAME_SIZE);
+    }
+
+    return table_vaddr;
+}
+
+uint64_t *_get_pmlt(uint64_t *pmlt, uint64_t pmlt_idx)
+{
+    uint64_t page_addr = PAGE_GET_ADDR(pmlt[pmlt_idx]);
+
+    if (!page_addr)
+    {
+        panic(NULL, "failed to get page address at index %llx in the PMLT at %llx", pmlt_idx, pmlt);
+    }
+
+    return (uint64_t *)HIGHER_HALF(page_addr);
+}

kernel/src/boot/limine.c

@@ -37,3 +37,6 @@ __attribute__((used, section(".limine_requests"))) volatile struct limine_memmap
 __attribute__((
     used, section(".limine_requests"))) volatile struct limine_hhdm_request limine_hhdm_request = {
     .id = LIMINE_HHDM_REQUEST_ID, .revision = 0};
+
+__attribute__((used, section(".limine_requests"))) volatile struct limine_executable_address_request
+    limine_address_request = {.id = LIMINE_EXECUTABLE_ADDRESS_REQUEST_ID, .revision = 0};

kernel/src/boot/limine.h

@@ -25,3 +25,4 @@ extern volatile uint64_t limine_base_revision[3];
 extern volatile struct limine_framebuffer_request limine_framebuffer_request;
 extern volatile struct limine_memmap_request limine_memmap_request;
 extern volatile struct limine_hhdm_request limine_hhdm_request;
+extern volatile struct limine_executable_address_request limine_address_request;

kernel/src/kernel.c

@@ -17,6 +17,7 @@
  */
 #include "arch/debug.h"
 #include "arch/interrupts.h"
+#include "arch/paging.h"
 #include "arch/system.h"
 #include "boot/limine.h"
 #include "mem/pmm.h"
@@ -29,6 +30,7 @@ void kstart()
     architecture_initialize();
 
     pmm_init(&limine_memmap_request, &limine_hhdm_request);
+    paging_init(&limine_memmap_request);
 
     log_info("Welcome to Zinix");
     log_info("If you are running in QEMU without graphics press `C-a x` to exit");