Add User Space Allocator to each Process

Author: My-Bad-2

kernel/include/libs/mutex.hpp

@@ -3,9 +3,12 @@
 #include <atomic>
 #include <cstdint>
 
-#include "task/process.hpp"
 #include "libs/spinlock.hpp"
 
+namespace kernel::task {
+struct Thread;
+}
+
 namespace kernel {
 class Mutex {
    public:

kernel/include/memory/vma.hpp

@@ -1,10 +1,13 @@
 #pragma once
 
-#include <cstdint>
-#include <cstddef>
+#include "libs/mutex.hpp"
 #include "libs/spinlock.hpp"
 #include "memory/pagemap.hpp"
 
+namespace kernel::task {
+struct Process;
+}
+
 namespace kernel::memory {
 struct VmRegion {
     uintptr_t start;
@@ -70,6 +73,7 @@ class VirtualMemoryAllocator {
     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);
@@ -91,4 +95,50 @@ 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,6 +4,7 @@
 #include "memory/pagemap.hpp"
 #include "libs/spinlock.hpp"
 #include "libs/intrusive_list.hpp"
+#include "memory/vma.hpp"
 
 namespace kernel::cpu {
 struct PerCpuData;
@@ -67,6 +68,7 @@ struct Process : public IntrusiveListNode<ProcessTag> {
 
     IntrusiveList<Process, ProcessTag> children;
     IntrusiveList<Thread, ProcessTag> threads;
+    memory::UserAddressSpace vma;
 
     int exit_code;
 
@@ -81,6 +83,4 @@ struct Process : public IntrusiveListNode<ProcessTag> {
    private:
     static std::atomic<size_t> next_pid;
 };
-
-extern Process* kernel_proc;
 }  // namespace kernel::task

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

@@ -0,0 +1,77 @@
+#include "cpu/registers.hpp"
+#include "hal/interrupt.hpp"
+#include "hal/smp_manager.hpp"
+#include "libs/log.hpp"
+#include "memory/vma.hpp"
+#include "hal//interface/interrupt.hpp"
+
+#define PF_PRESENT           0x01
+#define PF_WRITE             0x02
+#define PF_USER              0x04
+#define PF_RESERVED_WRITE    0x08
+#define PF_INSTRUCTION_FETCH 0x10
+#define PF_PROTECTION_KEY    0x20
+#define PF_SHADOW_STACK      0x40
+#define PF_SGX               0x8000
+
+namespace kernel::memory {
+class PageFaultHandler : public cpu::IInterruptHandler {
+   public:
+    const char* name() const {
+        return "Page Fault Handler!";
+    }
+
+    cpu::IrqStatus handle(cpu::arch::TrapFrame* frame) {
+        arch::Cr2 cr2         = arch::Cr2::read();
+        cpu::PerCpuData* cpu  = cpu::CpuCoreManager::get().get_current_core();
+        UserAddressSpace& uas = cpu->curr_thread->owner->vma;
+
+        if (!uas.handle_page_fault(cr2.linear_address, frame->error_code)) {
+            PANIC("Page Fault Not handled");
+            return cpu::IrqStatus::Unhandled;
+        }
+
+        return cpu::IrqStatus::Handled;
+    }
+};
+
+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);
+
+    LOG_DEBUG("PF Handler Called!");
+
+    if (!region) {
+        return false;
+    }
+
+    if ((error_code & PF_WRITE) && !(region->flags & Write)) {
+        LOG_ERROR("Write violation!");
+        return false;
+    }
+
+    if ((error_code & PF_USER) && !(region->flags & User)) {
+        LOG_ERROR("Privilege violation!");
+        return false;
+    }
+
+    uintptr_t page_base = fault_addr & ~(PAGE_SIZE_4K - 1);
+
+    if (this->page_map->translate(page_base) != 0) {
+        return true;
+    }
+
+    if (!this->page_map->map(page_base, region->flags, region->cache, PageSize::Size4K)) {
+        LOG_ERROR("Out of memory!");
+        return false;
+    }
+
+    return true;
+}
+
+void UserAddressSpace::arch_init() {
+    static PageFaultHandler pf_handler;
+    cpu::arch::InterruptDispatcher::register_handler(EXCEPTION_PAGE_FAULT, &pf_handler);
+}
+}  // namespace kernel::memory

kernel/src/hal/smp.cpp

@@ -1,6 +1,7 @@
 #include "boot/boot.h"
 #include "hal/smp_manager.hpp"
 #include "libs/log.hpp"
+#include "task/process.hpp"
 
 namespace kernel::cpu {
 namespace {