void*

src/arch/x86_64/main.c

@@ -3,6 +3,7 @@
 #include "interrupts/irq.h"
 #include "kernel.h"
 #include "mem/pmm.h"
+#include "mem/vmm.h"
 #include "panic.h"
 #include "util.h"
 
@@ -25,6 +26,8 @@ void x86_64_main(u32 magic, multiboot_info_t* info)
     enable_interrupts();
 
     pmm_init(info);
+    void* mem = vmm_alloc(1);
+    vmm_free(mem, 1);
 
     kernel_main();
 }

src/arch/x86_64/mem/vmm.c

@@ -15,7 +15,7 @@
 
 extern u64 pml4[];
 
-static u64 create_pte(u64 physical_address, u32 flags)
+static u64 create_2mb_pte(u64 physical_address, u32 flags)
 {
     if (physical_address & (PAGE_SIZE - 1))
     {
@@ -23,7 +23,7 @@ static u64 create_pte(u64 physical_address, u32 flags)
         panic("Failed to create PTE");
     }
 
-    return (physical_address & PTE_MASK) | (flags | PTE_PRESENT);
+    return (physical_address & PTE_MASK) | flags | PTE_PS;
 }
 
 void vmm_map(u64 physical_address, u64 virtual_address, u32 flags)
@@ -58,7 +58,7 @@ void vmm_map(u64 physical_address, u64 virtual_address, u32 flags)
         panic("Failed to map virtual to physical page");
     }
 
-    pd_physical_address[pd_idx] = create_pte(physical_address, flags);
+    pd_physical_address[pd_idx] = create_2mb_pte(physical_address, flags);
 }
 
 u64 vmm_unmap(u64 virtual_address)
@@ -97,17 +97,17 @@ u64 vmm_unmap(u64 virtual_address)
     return physical_address;
 }
 
-u64 vmm_alloc_address(u64 page_count)
+u64 vmm_alloc_address(size_t page_count)
 {
     panic("not implemented");
 }
 
-u64 vmm_free_address(u64 virtual_address, u64 page_count)
+u64 vmm_free_address(u64 virtual_address, size_t page_count)
 {
     panic("not implemented");
 }
 
-void* vmm_alloc(u64 page_count)
+void* vmm_alloc(size_t page_count)
 {
     u64 virtual_address = vmm_alloc_address(page_count);
 
@@ -119,19 +119,19 @@ void* vmm_alloc(u64 page_count)
             panic("Out of physical memory");
         }
 
-        vmm_map(physical_address, virtual_address + (i * PAGE_SIZE), PTE_WRITABLE | PTE_PS);
+        vmm_map(physical_address, virtual_address + (i * PAGE_SIZE), PTE_PRESENT | PTE_WRITABLE);
     }
 
     return (void*)virtual_address;
 }
 
-void vmm_free(u64 virtual_address, u64 page_count)
+void vmm_free(void* virtual_address, size_t page_count)
 {
     for (size_t i = 0; i < page_count; i++)
     {
-        u64 physical_address = vmm_unmap(virtual_address + (i * PAGE_SIZE));
+        u64 physical_address = vmm_unmap((u64)virtual_address + (i * PAGE_SIZE));
         pmm_free(physical_address);
     }
 
-    vmm_free_address(virtual_address, page_count);
+    vmm_free_address((u64)virtual_address, page_count);
 }

src/arch/x86_64/mem/vmm.h

@@ -8,13 +8,13 @@ void vmm_map(u64 physical_address, u64 virtual_address, u32 flags);
 u64 vmm_unmap(u64 virtual_address);
 
 // Allocates a free page aligned block of virtual addresses
-u64 vmm_alloc_address(u64 page_count);
+u64 vmm_alloc_address(size_t page_count);
 // Frees a block of virtual addresses previously allocated via `vmm_alloc_address`
 // Only use this function for pages mapped via `vmm_alloc_address`
-u64 vmm_free_address(u64 virtual_address, u64 page_count);
+u64 vmm_free_address(u64 virtual_address, size_t page_count);
 
 // Allocates and maps `page_count` continuous pages and returns the virtual address of the first page
-void* vmm_alloc(u64 page_count);
+void* vmm_alloc(size_t page_count);
 // Frees the pages allocated via `vmm_alloc` at the specified virtual address
 // Only use this function for pages mapped via `vmm_alloc`
-void vmm_free(u64 virtual_address, u64 page_count);
+void vmm_free(void* virtual_address, size_t page_count);