Implement proc_map () and proc_unmap () syscalls

kernel/amd64/proc.c

@@ -70,6 +70,8 @@ void proc_cleanup (struct proc* proc) {
     struct proc_mapping* mapping =
         list_entry (mapping_link, struct proc_mapping, proc_mappings_link);
 
+    DEBUG ("mapping vaddr=%p, paddr=%p, size=%zu\n", mapping->vaddr, mapping->paddr, mapping->size);
+
     pmm_free (mapping->paddr, mapping->size / PAGE_SIZE);
     list_remove (proc->mappings, mapping_link);
     free (mapping);

kernel/proc/proc.c

@@ -40,6 +40,9 @@ static bool proc_check_elf (uint8_t* elf) {
 
 bool proc_map (struct proc* proc, uintptr_t start_paddr, uintptr_t start_vaddr, size_t pages,
                uint32_t flags) {
+  DEBUG ("start_vaddr=%p, start_paddr=%p, pages=%zu, flags=%x\n", start_vaddr, start_paddr, pages,
+         flags);
+
   struct proc_mapping* mapping = malloc (sizeof (*mapping));
 
   if (mapping == NULL)
@@ -49,7 +52,7 @@ bool proc_map (struct proc* proc, uintptr_t start_paddr, uintptr_t start_vaddr,
   mapping->vaddr = start_vaddr;
   mapping->size = pages * PAGE_SIZE;
 
-  flags &= ~MM_PD_LOCK; /* clear LOCK flag if present, because we lock manualy */
+  flags &= ~(MM_PD_LOCK | MM_PD_RELOAD); /* clear LOCK flag if present, because we lock manualy */
 
   spin_lock (&proc->pd.lock);
 
@@ -71,6 +74,8 @@ bool proc_unmap (struct proc* proc, uintptr_t start_vaddr, size_t pages) {
   struct list_node_link *mapping_link, *mapping_link_tmp;
   bool used_tail_mapping = false;
 
+  DEBUG ("start_vaddr=%p, pages=%zu\n", start_vaddr, pages);
+
   struct proc_mapping* tail_mapping = malloc (sizeof (*tail_mapping));
   if (tail_mapping == NULL)
     return false;

kernel/proc/proc.h

@@ -46,6 +46,7 @@ void proc_sched (void);
 void proc_kill (struct proc* proc);
 bool proc_map (struct proc* proc, uintptr_t start_paddr, uintptr_t start_vaddr, size_t pages,
                uint32_t flags);
+bool proc_unmap (struct proc* proc, uintptr_t start_vaddr, size_t pages);
 struct elf_aux proc_load_segments (struct proc* proc, uint8_t* elf);
 void proc_init (void);
 

kernel/syscall/syscall.c

@@ -1,28 +1,63 @@
 #include <aux/compiler.h>
 #include <libk/std.h>
 #include <m/syscall_defs.h>
+#include <mm/pmm.h>
 #include <proc/proc.h>
 #include <sys/debug.h>
+#include <sys/mm.h>
 #include <syscall/syscall.h>
 
 #define DEFINE_SYSCALL(name)                                                                       \
   int name (struct proc* proc, uintptr_t UNUSED a1, uintptr_t UNUSED a2, uintptr_t UNUSED a3,      \
             uintptr_t UNUSED a4, uintptr_t UNUSED a5, uintptr_t UNUSED a6)
 
+/* int proc_quit (void) */
 DEFINE_SYSCALL (sys_proc_quit) {
   proc_kill (proc);
   proc_sched ();
   return SR_OK;
 }
 
+/* int proc_test (void) */
 DEFINE_SYSCALL (sys_proc_test) {
   DEBUG ("test syscall message!\n");
   return SR_OK;
 }
 
+/* int proc_map (uintptr_t vaddr, size_t pages, uint32_t flags) */
+DEFINE_SYSCALL (sys_proc_map) {
+  uintptr_t vaddr = a1;
+  size_t pages = (size_t)a2;
+  uint32_t flags = (uint32_t)a3;
+
+  if (vaddr % PAGE_SIZE != 0)
+    return -SR_UNALIGNED;
+
+  uintptr_t paddr = pmm_alloc (pages);
+  if (paddr == PMM_ALLOC_ERR)
+    return -SR_OOM_ERROR;
+
+  bool ok = proc_map (proc, paddr, vaddr, pages, flags);
+  return ok ? SR_OK : -SR_OOM_ERROR;
+}
+
+/* int proc_unmap (uintptr_t vaddr, size_t pages) */
+DEFINE_SYSCALL (sys_proc_unmap) {
+  uintptr_t vaddr = a1;
+  size_t pages = (size_t)a2;
+
+  if (vaddr % PAGE_SIZE != 0)
+    return -SR_UNALIGNED;
+
+  bool ok = proc_unmap (proc, vaddr, pages);
+  return ok ? SR_OK : -SR_OOM_ERROR;
+}
+
 static syscall_handler_func_t handler_table[] = {
     [SYS_PROC_QUIT] = &sys_proc_quit,
     [SYS_PROC_TEST] = &sys_proc_test,
+    [SYS_PROC_MAP] = &sys_proc_map,
+    [SYS_PROC_UNMAP] = &sys_proc_unmap,
 };
 
 syscall_handler_func_t syscall_find_handler (int syscall_num) {