Move mutex and mem create/cleanup functions into mutex.c and mem.c respectively

include/m/syscall_defs.h

@@ -12,5 +12,7 @@
 #define SYS_PROC_MUTEX_UNLOCK           9
 #define SYS_PROC_SPAWN_THREAD           10
 #define SYS_PROC_SCHED                  11
+#define SYS_PROC_TRANSLATE_V2P          12
+#define SYS_PROC_MEM_UNREF              13
 
 #endif // _M_SYSCALL_DEFS_H

kernel/proc/mem.c

@@ -0,0 +1,37 @@
+#include <libk/std.h>
+#include <mm/pmm.h>
+#include <proc/mem.h>
+#include <proc/proc.h>
+#include <proc/resource.h>
+#include <sync/spin_lock.h>
+
+bool proc_create_resource_mem (struct proc_resource_mem* mem, struct proc_resource_mem_init* init) {
+  if (init->pages == 0)
+    return false;
+
+  uintptr_t paddr = pmm_alloc (init->pages);
+  if (paddr == PMM_ALLOC_ERR)
+    return false;
+
+  mem->paddr = paddr;
+  mem->pages = mem->alive_pages = init->pages;
+
+  return true;
+}
+
+void proc_cleanup_resource_mem (struct proc* proc, struct proc_resource* resource) {
+  (void)proc;
+  pmm_free (resource->u.mem.paddr, resource->u.mem.pages);
+}
+
+void proc_mem_unref (struct proc* proc, struct proc_resource_mem* mem, size_t pages) {
+  spin_lock_ctx_t ctxrs;
+
+  spin_lock (&mem->resource->lock, &ctxrs);
+  mem->alive_pages -= pages;
+  ptrdiff_t current_pages = mem->alive_pages;
+  spin_unlock (&mem->resource->lock, &ctxrs);
+
+  if (current_pages <= 0)
+    proc_drop_resource (proc, mem->resource);
+}

kernel/proc/mem.h

@@ -0,0 +1,25 @@
+#ifndef _KERNEL_PROC_MEM_H
+#define _KERNEL_PROC_MEM_H
+
+#include <libk/std.h>
+
+struct proc;
+struct proc_resource;
+
+struct proc_resource_mem {
+  struct proc_resource* resource;
+
+  uintptr_t paddr;
+  size_t pages;
+  ptrdiff_t alive_pages;
+};
+
+struct proc_resource_mem_init {
+  size_t pages;
+};
+
+bool proc_create_resource_mem (struct proc_resource_mem* mem, struct proc_resource_mem_init* init);
+void proc_cleanup_resource_mem (struct proc* proc, struct proc_resource* resource);
+void proc_mem_unref (struct proc* proc, struct proc_resource_mem* mem, size_t pages);
+
+#endif // _KERNEL_PROC_MEM_H

kernel/proc/mutex.c

@@ -1,25 +1,38 @@
 #include <libk/assert.h>
 #include <libk/rbtree.h>
 #include <libk/std.h>
+#include <libk/string.h>
 #include <proc/mutex.h>
 #include <proc/proc.h>
 #include <sync/spin_lock.h>
 #include <sys/debug.h>
 
+bool proc_create_resource_mutex (struct proc_mutex* mutex) {
+  memset (mutex, 0, sizeof (*mutex));
+
+  return true;
+}
+
+void proc_cleanup_resource_mutex (struct proc* proc, struct proc_resource* resource) {
+  struct proc_mutex* mutex = &resource->u.mutex;
+
+  proc_mutex_unlock (proc, mutex);
+}
+
 void proc_mutex_lock (struct proc* proc, struct proc_mutex* mutex) {
   spin_lock_ctx_t ctxmt;
 
 try:
-  spin_lock (&mutex->lock, &ctxmt);
+  spin_lock (&mutex->resource->lock, &ctxmt);
 
   if (!mutex->locked || mutex->owner == proc) {
     mutex->locked = true;
     mutex->owner = proc;
-    spin_unlock (&mutex->lock, &ctxmt);
+    spin_unlock (&mutex->resource->lock, &ctxmt);
     return;
   }
 
-  spin_unlock (&mutex->lock, &ctxmt);
+  spin_unlock (&mutex->resource->lock, &ctxmt);
 
   proc_suspend (proc, &mutex->suspension_q);
 
@@ -29,10 +42,10 @@ try:
 bool proc_mutex_unlock (struct proc* proc, struct proc_mutex* mutex) {
   spin_lock_ctx_t ctxmt, ctxsq;
 
-  spin_lock (&mutex->lock, &ctxmt);
+  spin_lock (&mutex->resource->lock, &ctxmt);
 
   if (mutex->owner != proc) {
-    spin_unlock (&mutex->lock, &ctxmt);
+    spin_unlock (&mutex->resource->lock, &ctxmt);
     return false;
   }
 
@@ -47,7 +60,7 @@ bool proc_mutex_unlock (struct proc* proc, struct proc_mutex* mutex) {
     mutex->owner = resumed_proc;
 
     spin_unlock (&mutex->suspension_q.lock, &ctxsq);
-    spin_unlock (&mutex->lock, &ctxmt);
+    spin_unlock (&mutex->resource->lock, &ctxmt);
     proc_resume (resumed_proc);
 
     return true;
@@ -58,7 +71,7 @@ bool proc_mutex_unlock (struct proc* proc, struct proc_mutex* mutex) {
   mutex->locked = false;
   mutex->owner = NULL;
 
-  spin_unlock (&mutex->lock, &ctxmt);
+  spin_unlock (&mutex->resource->lock, &ctxmt);
 
   return true;
 }

kernel/proc/mutex.h

@@ -3,17 +3,20 @@
 
 #include <libk/std.h>
 #include <proc/suspension_q.h>
-#include <sync/spin_lock.h>
 
 struct proc;
+struct proc_resource;
 
 struct proc_mutex {
-  spin_lock_t lock;
+  struct proc_resource* resource;
+
   bool locked;
   struct proc_suspension_q suspension_q;
   struct proc* owner;
 };
 
+bool proc_create_resource_mutex (struct proc_mutex* mutex);
+void proc_cleanup_resource_mutex (struct proc* proc, struct proc_resource* resource);
 void proc_mutex_lock (struct proc* proc, struct proc_mutex* mutex);
 bool proc_mutex_unlock (struct proc* proc, struct proc_mutex* mutex);
 

kernel/proc/resource.c

@@ -42,38 +42,6 @@ void proc_drop_resource (struct proc* proc, struct proc_resource* resource) {
   }
 }
 
-static bool proc_create_resource_mem (struct proc_resource_mem* mem,
-                                      struct proc_resource_mem_init* init) {
-  if (init->pages == 0)
-    return false;
-
-  uintptr_t paddr = pmm_alloc (init->pages);
-  if (paddr == PMM_ALLOC_ERR)
-    return false;
-
-  mem->paddr = paddr;
-  mem->pages = init->pages;
-
-  return true;
-}
-
-static void proc_cleanup_resource_mem (struct proc* proc, struct proc_resource* resource) {
-  (void)proc;
-  pmm_free (resource->u.mem.paddr, resource->u.mem.pages);
-}
-
-static bool proc_create_resource_mutex (struct proc_mutex* mutex) {
-  memset (mutex, 0, sizeof (*mutex));
-
-  return true;
-}
-
-static void proc_cleanup_resource_mutex (struct proc* proc, struct proc_resource* resource) {
-  struct proc_mutex* mutex = &resource->u.mutex;
-
-  proc_mutex_unlock (proc, mutex);
-}
-
 struct proc_resource* proc_create_resource (struct proc* proc, int rid, int type, int vis,
                                             void* data) {
   spin_lock_ctx_t ctxpr;
@@ -101,12 +69,14 @@ struct proc_resource* proc_create_resource (struct proc* proc, int rid, int type
     struct proc_resource_mem_init* mem_init = data;
     proc_create_resource_mem (&resource->u.mem, mem_init);
     resource->ops.cleanup = &proc_cleanup_resource_mem;
+    resource->u.mem.resource = resource;
     DEBUG ("PR_MEM resource=%p type=%d rid=%d paddr=%p, pages=%zu\n", resource, resource->type,
            resource->rid, resource->u.mem.paddr, resource->u.mem.pages);
   } break;
   case PR_MUTEX: {
     proc_create_resource_mutex (&resource->u.mutex);
     resource->ops.cleanup = &proc_cleanup_resource_mutex;
+    resource->u.mutex.resource = resource;
     DEBUG ("PR_MUTEX resource=%p, type=%d rid=%d\n", resource, resource->type, resource->rid);
   } break;
   default: {

kernel/proc/resource.h

@@ -3,6 +3,7 @@
 
 #include <libk/rbtree.h>
 #include <libk/std.h>
+#include <proc/mem.h>
 #include <proc/mutex.h>
 #include <sync/spin_lock.h>
 
@@ -13,15 +14,7 @@
 #define RV_PUBLIC  1
 
 struct proc;
-
-struct proc_resource_mem {
-  uintptr_t paddr;
-  size_t pages;
-};
-
-struct proc_resource_mem_init {
-  size_t pages;
-};
+struct proc_resource;
 
 struct proc_resource {
   int type;

kernel/proc/src.mk

@@ -1,7 +1,9 @@
 c += proc/proc.c \
 		 proc/resource.c \
-		 proc/mutex.c
+		 proc/mutex.c \
+		 proc/mem.c
 
 o += proc/proc.o \
 		 proc/resource.o \
-		 proc/mutex.o
+		 proc/mutex.o \
+		 proc/mem.o

kernel/syscall/syscall.c

@@ -4,6 +4,7 @@
 #include <m/status.h>
 #include <m/syscall_defs.h>
 #include <mm/pmm.h>
+#include <proc/mem.h>
 #include <proc/mutex.h>
 #include <proc/proc.h>
 #include <proc/resource.h>
@@ -130,6 +131,7 @@ DEFINE_SYSCALL (sys_proc_mutex_lock) {
   return ST_OK;
 }
 
+/* int proc_mutex_unlock (int mutex_rid) */
 DEFINE_SYSCALL (sys_proc_mutex_unlock) {
   spin_lock_ctx_t ctxpr;
   int rid = (int)a1;
@@ -200,6 +202,58 @@ DEFINE_SYSCALL (sys_proc_sched) {
   return ST_OK;
 }
 
+DEFINE_SYSCALL (sys_proc_translate_v2p) {
+  struct limine_hhdm_response* hhdm = limine_hhdm_request.response;
+  spin_lock_ctx_t ctxprpd;
+  int result = ST_OK;
+
+  uintptr_t vaddr = a1;
+  uintptr_t* out_paddr_buf = (uintptr_t*)a2;
+
+  spin_lock (&proc->pd->lock, &ctxprpd);
+
+  uintptr_t out_paddr_buf_paddr = mm_v2p (proc->pd, (uintptr_t)out_paddr_buf, 0);
+
+  if (!mm_validate_buffer (proc->pd, (uintptr_t)out_paddr_buf, sizeof (uintptr_t), 0)) {
+    spin_unlock (&proc->pd->lock, &ctxprpd);
+    return -ST_BAD_ADDRESS_SPACE;
+  }
+
+  uintptr_t* out_paddr_buf_vaddr = (uintptr_t*)((uintptr_t)hhdm->offset + out_paddr_buf_paddr);
+
+  uintptr_t translated_addr = mm_v2p (proc->pd, vaddr, 0);
+  if (translated_addr == 0) {
+    result = -ST_BAD_ADDRESS_SPACE;
+    goto done;
+  }
+
+  *out_paddr_buf_vaddr = translated_addr;
+
+done:
+  spin_unlock (&proc->pd->lock, &ctxprpd);
+  return result;
+}
+
+/* int proc_resource_mem_unref (int mem_rid, size_t pages) */
+DEFINE_SYSCALL (sys_proc_mem_unref) {
+  spin_lock_ctx_t ctxpr;
+  int rid = (int)a1;
+  size_t pages = (size_t)a2;
+
+  struct proc_resource* resource;
+  spin_lock (&proc->lock, &ctxpr);
+  rbtree_find (struct proc_resource, &proc->resource_tree, rid, resource, proc_resource_tree_link,
+               rid);
+  spin_unlock (&proc->lock, &ctxpr);
+
+  if (resource == NULL)
+    return -ST_NOT_FOUND;
+
+  proc_mem_unref (proc, &resource->u.mem, pages);
+
+  return ST_OK;
+}
+
 static syscall_handler_func_t handler_table[] = {
     [SYS_PROC_QUIT] = &sys_proc_quit,
     [SYS_PROC_TEST] = &sys_proc_test,
@@ -212,6 +266,8 @@ static syscall_handler_func_t handler_table[] = {
     [SYS_PROC_MUTEX_UNLOCK] = &sys_proc_mutex_unlock,
     [SYS_PROC_SPAWN_THREAD] = &sys_proc_spawn_thread,
     [SYS_PROC_SCHED] = &sys_proc_sched,
+    [SYS_PROC_TRANSLATE_V2P] = &sys_proc_translate_v2p,
+    [SYS_PROC_MEM_UNREF] = &sys_proc_mem_unref,
 };
 
 syscall_handler_func_t syscall_find_handler (int syscall_num) {

libmsl/alloc/liballoc.c

@@ -6,7 +6,7 @@
 
 static int liballoc_mutex;
 static uintptr_t liballoc_map_base = PROC_MAP_BASE;
-static int mem_rid_base = 10000;
+static int mem_rid_base = 1000000;
 
 void liballoc_init (void) { liballoc_mutex = proc_create_resource_mutex (100, RV_PRIVATE); }
 
@@ -36,7 +36,20 @@ void* liballoc_alloc (int pages) {
   return (void*)old_base;
 }
 
-int liballoc_free (void* ptr, int pages) { return 0; }
+int liballoc_free (void* ptr, int pages) {
+  int res;
+  uintptr_t out_paddr;
+
+  res = proc_translate_v2p ((uintptr_t)ptr, &out_paddr);
+  if (res < 0)
+    return res;
+
+  res = proc_unmap ((uintptr_t)ptr, pages);
+  if (res < 0)
+    return res;
+
+  return proc_mem_unref (out_paddr, pages);
+}
 
 /**  Durand's Ridiculously Amazing Super Duper Memory functions.  */
 

libmsl/m/proc.c

@@ -41,4 +41,12 @@ int proc_spawn_thread (uintptr_t vstack_top, size_t stack_size, void* entry) {
                   0);
 }
 
+int proc_translate_v2p (uintptr_t vaddr, uintptr_t* out_paddr) {
+  return syscall (SYS_PROC_TRANSLATE_V2P, vaddr, (uintptr_t)out_paddr, 0, 0, 0, 0);
+}
+
+int proc_mem_unref (uintptr_t paddr, size_t pages) {
+  return syscall (SYS_PROC_MEM_UNREF, paddr, (uintptr_t)pages, 0, 0, 0, 0);
+}
+
 int proc_sched (void) { return syscall (SYS_PROC_SCHED, 0, 0, 0, 0, 0, 0); }

libmsl/m/proc.h

@@ -27,6 +27,7 @@ int proc_mutex_lock (int mutex_rid);
 int proc_mutex_unlock (int mutex_rid);
 int proc_spawn_thread (uintptr_t vstack_top, size_t stack_size, void* entry);
 int proc_sched (void);
-int proc_translate_resource_mem (uintptr_t vaddr);
+int proc_translate_v2p (uintptr_t vaddr, uintptr_t* out_paddr);
+int proc_mem_unref (uintptr_t paddr, size_t pages);
 
 #endif // _LIBMSL_M_PROC_H