Add mmap() and munmap() in process

Author: My-Bad-2

kernel/include/memory/user_address_space.hpp

@@ -58,7 +58,8 @@ class UserAddressSpace {
     ~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);
+    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);
 

kernel/include/task/process.hpp

@@ -6,6 +6,14 @@
 #include "libs/intrusive_list.hpp"
 #include "memory/user_address_space.hpp"
 
+#define PROT_READ  0x01
+#define PROT_WRITE 0x02
+#define PROT_EXEC  0x04
+#define PROT_NONE  0x08
+
+#define MAP_HUGE_2MB 0x01
+#define MAP_HUGE_1GB 0x02
+
 namespace kernel::cpu {
 struct PerCpuData;
 }
@@ -78,6 +86,9 @@ struct Process : public IntrusiveListNode<ProcessTag> {
     Process();                      // User
     ~Process();
 
+    void* mmap(void* addr, size_t len, int prot, int flags);
+    void munmap(void* ptr, size_t len);
+
     static void init();
 
    private:

kernel/src/task/process.cpp

@@ -1,6 +1,9 @@
+#include "task/process.hpp"
 #include "hal/smp_manager.hpp"
 #include "boot/boot.h"
+#include "memory/memory.hpp"
 #include "memory/vma.hpp"
+#include "libs/math.hpp"
 
 namespace kernel::task {
 Process* Process::kernel_proc         = nullptr;
@@ -85,6 +88,57 @@ Process::~Process() {
     }
 }
 
+void* Process::mmap(void* addr, size_t len, int prot, int flags) {
+    uint8_t flag = 0;
+
+    if (prot & PROT_READ) {
+        flag |= memory::Read;
+    }
+
+    if (prot & PROT_WRITE) {
+        flag |= memory::Write;
+    }
+
+    if (prot & PROT_EXEC) {
+        flag |= memory::Execute;
+    }
+
+    if (prot & PROT_NONE) {
+        // Do nothing
+    }
+
+    memory::PageSize type = memory::PageSize::Size4K;
+    uintptr_t page_size   = memory::PAGE_SIZE_4K;
+
+    if (flags & MAP_HUGE_2MB) {
+        type      = memory::PageSize::Size2M;
+        page_size = memory::PAGE_SIZE_2M;
+    }
+
+    if (flags & MAP_HUGE_1GB) {
+        type      = memory::PageSize::Size1G;
+        page_size = memory::PAGE_SIZE_1G;
+    }
+
+    size_t aligned_size = align_up(len, page_size);
+    void* ret           = nullptr;
+
+    if (addr) {
+        if (this->vma.allocate_specific(reinterpret_cast<uintptr_t>(addr), aligned_size, flag,
+                                        type)) {
+            ret = addr;
+        }
+    } else {
+        ret = this->vma.allocate(aligned_size, flag, type);
+    }
+
+    return ret;
+}
+
+void Process::munmap(void* ptr, size_t) {
+    return this->vma.free(ptr);
+}
+
 void Process::init() {
     kernel_proc = new Process(memory::PageMap::get_kernel_map());
 }