APIC, HPET, virtual memory

kernel/amd64/mm.c

@@ -0,0 +1,163 @@
+#include <aux/compiler.h>
+#include <libk/std.h>
+#include <libk/string.h>
+#include <limine/requests.h>
+#include <mm/pmm.h>
+#include <sync/spin_lock.h>
+#include <sys/mm.h>
+
+#define AMD64_PG_PRESENT (1 << 0)
+#define AMD64_PG_RW      (1 << 1)
+#define AMD64_PG_USER    (1 << 2)
+
+#define AMD64_PG_TABLE_ENTRIES_MAX 512
+
+struct pg_index {
+  uint16_t pml4, pml3, pml2, pml1;
+} PACKED;
+
+struct pd kernel_pd = {.lock = SPIN_LOCK_INIT};
+
+static uintptr_t amd64_current_cr3 (void) {
+  uintptr_t cr3;
+  __asm__ volatile ("movq %%cr3, %0" : "=r"(cr3)::"memory");
+  return cr3;
+}
+
+static struct pg_index amd64_mm_page_index (uint64_t vaddr) {
+  struct pg_index ret;
+
+  ret.pml4 = ((vaddr >> 39) & 0x1FF);
+  ret.pml3 = ((vaddr >> 30) & 0x1FF);
+  ret.pml2 = ((vaddr >> 21) & 0x1FF);
+  ret.pml1 = ((vaddr >> 12) & 0x1FF);
+
+  return ret;
+}
+
+static uint64_t* amd64_mm_next_table (uint64_t* table, uint64_t entry_idx,
+                                      bool alloc) {
+  uint64_t entry = table[entry_idx];
+  uint64_t paddr;
+
+  struct limine_hhdm_response* hhdm = limine_hhdm_request.response;
+
+  if (entry & AMD64_PG_PRESENT)
+    paddr = entry & ~0xFFFULL;
+  else {
+    if (!alloc)
+      return NULL;
+
+    paddr = pmm_alloc (1);
+
+    if (paddr == 0)
+      return NULL;
+
+    memset ((void*)((uintptr_t)hhdm->offset + (uintptr_t)paddr), 0, PAGE_SIZE);
+    table[entry_idx] = paddr | AMD64_PG_PRESENT | AMD64_PG_RW;
+  }
+
+  return (uint64_t*)((uintptr_t)hhdm->offset + (uintptr_t)paddr);
+}
+
+static uint64_t amd64_mm_resolve_flags (uint32_t generic) {
+  uint64_t flags = 0;
+
+  flags |= ((generic & MM_PG_PRESENT) ? AMD64_PG_PRESENT : 0);
+  flags |= ((generic & MM_PG_RW) ? AMD64_PG_RW : 0);
+  flags |= ((generic & MM_PG_USER) ? AMD64_PG_USER : 0);
+
+  return flags;
+}
+
+static void amd64_reload_cr3 (void) {
+  uint64_t cr3;
+  __asm__ volatile ("movq %%cr3, %0; movq %0, %%cr3" : "=r"(cr3)::"memory");
+}
+
+void mm_map_page (struct pd* pd, uintptr_t paddr, uintptr_t vaddr,
+                  uint32_t flags) {
+  struct limine_hhdm_response* hhdm = limine_hhdm_request.response;
+  bool do_reload = false;
+
+  if (flags & MM_PD_LOCK)
+    spin_lock (&pd->lock);
+
+  uint64_t amd64_flags = amd64_mm_resolve_flags (flags);
+
+  uint64_t* pml4 = (uint64_t*)(pd->cr3_paddr + (uintptr_t)hhdm->offset);
+  struct pg_index pg_index = amd64_mm_page_index (vaddr);
+
+  uint64_t* pml3 = amd64_mm_next_table (pml4, pg_index.pml4, true);
+  if (pml3 == NULL)
+    goto done;
+
+  uint64_t* pml2 = amd64_mm_next_table (pml3, pg_index.pml3, true);
+  if (pml2 == NULL)
+    goto done;
+
+  uint64_t* pml1 = amd64_mm_next_table (pml2, pg_index.pml2, true);
+  if (pml1 == NULL)
+    goto done;
+
+  uint64_t* pte = &pml1[pg_index.pml1];
+
+  *pte = ((paddr & ~0xFFFULL) | (amd64_flags & 0x7ULL));
+  do_reload = true;
+
+done:
+  if (do_reload)
+    amd64_reload_cr3 ();
+
+  if (flags & MM_PD_LOCK)
+    spin_unlock (&pd->lock);
+}
+
+void mm_map_kernel_page (uintptr_t paddr, uintptr_t vaddr, uint32_t flags) {
+  mm_map_page (&kernel_pd, paddr, vaddr, flags);
+}
+
+void mm_unmap_page (struct pd* pd, uintptr_t vaddr, uint32_t flags) {
+  struct limine_hhdm_response* hhdm = limine_hhdm_request.response;
+  bool do_reload = false;
+
+  if (flags & MM_PD_LOCK)
+    spin_lock (&pd->lock);
+
+  uint64_t* pml4 = (uint64_t*)(pd->cr3_paddr + (uintptr_t)hhdm->offset);
+  struct pg_index pg_index = amd64_mm_page_index (vaddr);
+
+  uint64_t* pml3 = amd64_mm_next_table (pml4, pg_index.pml4, true);
+  if (pml3 == NULL)
+    goto done;
+
+  uint64_t* pml2 = amd64_mm_next_table (pml3, pg_index.pml3, true);
+  if (pml2 == NULL)
+    goto done;
+
+  uint64_t* pml1 = amd64_mm_next_table (pml2, pg_index.pml2, true);
+  if (pml1 == NULL)
+    goto done;
+
+  uint64_t* pte = &pml1[pg_index.pml1];
+
+  *pte &= ~AMD64_PG_PRESENT;
+  do_reload = true;
+
+done:
+  if (do_reload)
+    amd64_reload_cr3 ();
+
+  if (flags & MM_PD_LOCK)
+    spin_unlock (&pd->lock);
+}
+
+void mm_unmap_kernel_page (uintptr_t vaddr, uint32_t flags) {
+  mm_unmap_page (&kernel_pd, vaddr, flags);
+}
+
+void mm_lock_kernel (void) { spin_lock (&kernel_pd.lock); }
+
+void mm_unlock_kernel (void) { spin_unlock (&kernel_pd.lock); }
+
+void mm_init (void) { kernel_pd.cr3_paddr = amd64_current_cr3 (); }