Add support for 2MB/1GB pages in user address space

Author: My-Bad-2

kernel/include/memory/user_address_space.hpp

@@ -0,0 +1,95 @@
+#pragma once
+
+#include "memory/pagemap.hpp"
+#include "libs/mutex.hpp"
+#include "libs/spinlock.hpp"
+#include "memory/pagemap.hpp"
+
+namespace kernel::task {
+struct Process;
+}
+
+namespace kernel::memory {
+struct UserVmRegion {
+    uintptr_t start;
+    size_t size;
+
+    size_t gap;
+    size_t subtree_max_gap;
+
+    uint8_t flags;
+    PageSize page_size;
+    CacheType cache;
+
+    bool is_red          = true;
+    UserVmRegion* parent = nullptr;
+    UserVmRegion* left   = nullptr;
+    UserVmRegion* right  = nullptr;
+
+    uintptr_t end() const {
+        return this->start + this->size;
+    }
+};
+
+class UserVmRegionAllocator {
+   public:
+    UserVmRegion* allocate();
+    void deallocate(UserVmRegion* node);
+
+   private:
+    void refill();
+
+    struct FreeNode {
+        FreeNode* next;
+    };
+
+    FreeNode* free_head = nullptr;
+    SpinLock lock;
+};
+
+class UserAddressSpace {
+   public:
+    static constexpr uintptr_t USER_START = 0x1000;
+    static constexpr uintptr_t USER_END   = 0x00007FFFFFFFFFFF;
+
+    static void arch_init();
+
+    void init(task::Process* proc);
+    ~UserAddressSpace();
+
+    void* allocate(size_t size, uint8_t flags = Read | Write, PageSize type = PageSize::Size4K);
+    bool allocate_specific(uintptr_t virt_addr, size_t size, uint8_t flags, PageSize type = PageSize::Size4K);
+    void free(void* ptr);
+    bool handle_page_fault(uintptr_t fault_addr, size_t error_code);
+
+   private:
+    uintptr_t find_hole(size_t size, size_t alignment);
+    uintptr_t find_hole(UserVmRegion* node, size_t size, size_t alignment);
+
+    UserVmRegion* find_region_containing(uintptr_t addr);
+    bool check_overlap(uintptr_t start, size_t size);
+
+    void insert_region(uintptr_t start, size_t size, uint8_t flags, CacheType cache, PageSize type);
+    void delete_node(UserVmRegion* z);
+
+    void rotate_left(UserVmRegion* x);
+    void rotate_right(UserVmRegion* x);
+    void insert_fixup(UserVmRegion* z);
+    void delete_fixup(UserVmRegion* x);
+
+    void update_node_metadata(UserVmRegion* x);
+    void update_path_to_root(UserVmRegion* x);
+
+    UserVmRegion* predecessor(UserVmRegion* node);
+    UserVmRegion* successor(UserVmRegion* node);
+
+    void free_tree(UserVmRegion* node);
+
+    Mutex mutex;
+    PageMap* page_map;
+    task::Process* process;
+    UserVmRegion* root;
+    UserVmRegion* cached_cursor;
+    UserVmRegionAllocator metadata_allocator;
+};
+}  // namespace kernel::memory

kernel/include/memory/vma.hpp

@@ -95,50 +95,4 @@ class VirtualMemoryAllocator {
     VmRegion* cached_cursor = nullptr;
     VmRegionAllocator metadata_allocator;
 };
-
-class UserAddressSpace {
-   public:
-    static constexpr uintptr_t USER_START = 0x1000;
-    static constexpr uintptr_t USER_END   = 0x00007FFFFFFFFFFF;
-
-    static void arch_init();
-
-    void init(task::Process* proc);
-    ~UserAddressSpace();
-
-    void* allocate(size_t size, uint8_t flags = Read | Write);
-    bool allocate_specific(uintptr_t virt_addr, size_t size, uint8_t flags);
-    void free(void* ptr);
-    bool handle_page_fault(uintptr_t fault_addr, size_t error_code);
-
-   private:
-    uintptr_t find_hole(size_t size, size_t alignment);
-    uintptr_t find_hole(VmRegion* node, size_t size, size_t alignment);
-
-    VmRegion* find_region_containing(uintptr_t addr);
-    bool check_overlap(uintptr_t start, size_t size);
-
-    void insert_region(uintptr_t start, size_t size, uint8_t flags, CacheType cache);
-    void delete_node(VmRegion* z);
-
-    void rotate_left(VmRegion* x);
-    void rotate_right(VmRegion* x);
-    void insert_fixup(VmRegion* z);
-    void delete_fixup(VmRegion* x);
-
-    void update_node_metadata(VmRegion* x);
-    void update_path_to_root(VmRegion* x);
-
-    VmRegion* predecessor(VmRegion* node);
-    VmRegion* successor(VmRegion* node);
-
-    void free_tree(VmRegion* node);
-
-    Mutex mutex;
-    PageMap* page_map;
-    task::Process* process;
-    VmRegion* root;
-    VmRegion* cached_cursor;
-    VmRegionAllocator metadata_allocator;
-};
 }  // namespace kernel::memory

kernel/include/task/process.hpp

@@ -4,7 +4,7 @@
 #include "memory/pagemap.hpp"
 #include "libs/spinlock.hpp"
 #include "libs/intrusive_list.hpp"
-#include "memory/vma.hpp"
+#include "memory/user_address_space.hpp"
 
 namespace kernel::cpu {
 struct PerCpuData;

kernel/src/arch/x86_64/memory/user_address_space.cpp

@@ -2,6 +2,7 @@
 #include "hal/interrupt.hpp"
 #include "hal/smp_manager.hpp"
 #include "libs/log.hpp"
+#include "memory/memory.hpp"
 #include "memory/vma.hpp"
 #include "hal//interface/interrupt.hpp"
 
@@ -38,7 +39,7 @@ class PageFaultHandler : public cpu::IInterruptHandler {
 bool UserAddressSpace::handle_page_fault(uintptr_t fault_addr, size_t error_code) {
     LockGuard guard(this->mutex);
 
-    VmRegion* region = this->find_region_containing(fault_addr);
+    UserVmRegion* region = this->find_region_containing(fault_addr);
 
     LOG_DEBUG("PF Handler Called!");
 
@@ -56,13 +57,21 @@ bool UserAddressSpace::handle_page_fault(uintptr_t fault_addr, size_t error_code
         return false;
     }
 
-    uintptr_t page_base = fault_addr & ~(PAGE_SIZE_4K - 1);
+    size_t alignment = PAGE_SIZE_4K;
+
+    if (region->page_size == PageSize::Size1G) {
+        alignment = PAGE_SIZE_1G;
+    } else if (region->page_size == PageSize::Size2M) {
+        alignment = PAGE_SIZE_2M;
+    }
+
+    uintptr_t page_base = fault_addr & ~(alignment - 1);
 
     if (this->page_map->translate(page_base) != 0) {
         return true;
     }
 
-    if (!this->page_map->map(page_base, region->flags, region->cache, PageSize::Size4K)) {
+    if (!this->page_map->map(page_base, region->flags, region->cache, region->page_size)) {
         LOG_ERROR("Out of memory!");
         return false;
     }