Redesign syscalls

kernel/amd64/intr.c

@@ -157,7 +157,7 @@ static void amd64_intr_exception (struct saved_regs* regs) {
                regs->rbx);
 
   if (regs->cs == (GDT_UCODE | 0x03)) {
-    proc_kill (thiscpu->proc_current, regs);
+    proc_kill (thiscpu->proc_current);
   } else {
     spin ();
   }

kernel/proc/proc.c

@@ -337,7 +337,7 @@ void proc_sched (void* regs) {
   }
 }
 
-void proc_kill (struct proc* proc, void* regs) {
+void proc_kill (struct proc* proc) {
   spin_lock_ctx_t ctxpr, ctxcpu;
   struct cpu* cpu = proc->cpu;
 

kernel/proc/proc.h

@@ -63,7 +63,7 @@ struct proc {
 void proc_suspend (struct proc* proc, struct proc_suspension_q* sq);
 void proc_resume (struct proc* proc);
 void proc_sched (void* regs);
-void proc_kill (struct proc* proc, void* regs);
+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);

kernel/syscall/syscall.c

@@ -2,7 +2,6 @@
 #include <libk/assert.h>
 #include <libk/std.h>
 #include <limine/requests.h>
-#include <m/resource_buffer.h>
 #include <m/status.h>
 #include <m/syscall_defs.h>
 #include <mm/pmm.h>
@@ -40,180 +39,123 @@ static void* sys_get_user_buffer (struct proc* proc, uintptr_t uvaddr, size_t si
   return (void*)out_kvaddr;
 }
 
-/* int proc_quit (void) */
-DEFINE_SYSCALL (sys_proc_quit) {
-  proc_kill (proc, regs);
+/* int quit (void) */
+DEFINE_SYSCALL (sys_quit) {
+  proc_kill (proc);
   return ST_OK;
 }
 
-/* int proc_test (void) */
-DEFINE_SYSCALL (sys_proc_test) {
+/* int test (void) */
+DEFINE_SYSCALL (sys_test) {
   char c = (char)a1;
   DEBUG ("test syscall from %d! %c\n", proc->pid, c);
   return ST_OK;
 }
 
-/* int proc_map (uintptr_t paddr, uintptr_t vaddr, size_t pages, uint32_t flags) */
-DEFINE_SYSCALL (sys_proc_map) {
-  uintptr_t paddr = a1;
-  uintptr_t vaddr = a2;
-  size_t pages = (size_t)a3;
+/* int map (int mem_rid, int vis, uintptr_t vaddr, uint32_t flags) */
+DEFINE_SYSCALL (sys_map) {
+  spin_lock_ctx_t ctxrs;
+
+  int mem_rid = (int)a1;
+  int vis = (int)a2;
+  uintptr_t vaddr = a3;
   uint32_t flags = (uint32_t)a4;
 
   if (vaddr % PAGE_SIZE != 0)
     return -ST_UNALIGNED;
 
-  if (paddr % PAGE_SIZE != 0)
-    return -ST_UNALIGNED;
+  if (!(vis == RV_PUBLIC || vis == RV_PRIVATE))
+    return -ST_BAD_RESOURCE;
 
-  bool ok = proc_map (proc, paddr, vaddr, pages, flags);
-  return ok ? ST_OK : -ST_OOM_ERROR;
+  struct proc_resource* mem_resource = proc_find_resource (proc, mem_rid, vis);
+
+  if (mem_resource == NULL) {
+    return -ST_NOT_FOUND;
+  }
+
+  spin_lock (&mem_resource->lock, &ctxrs);
+
+  if (mem_resource->type != PR_MEM) {
+    spin_unlock (&mem_resource->lock, &ctxrs);
+    return -ST_BAD_RESOURCE;
+  }
+
+  uintptr_t paddr = mem_resource->u.mem.paddr;
+  size_t pages = mem_resource->u.mem.pages;
+
+  spin_unlock (&mem_resource->lock, &ctxrs);
+
+  return proc_map (proc, paddr, vaddr, pages, flags) ? ST_OK : -ST_OOM_ERROR;
 }
 
-/* int proc_unmap (uintptr_t vaddr, size_t pages) */
-DEFINE_SYSCALL (sys_proc_unmap) {
+/* int unmap (uintptr_t vaddr, size_t pages) */
+DEFINE_SYSCALL (sys_unmap) {
   uintptr_t vaddr = a1;
   size_t pages = (size_t)a2;
 
   if (vaddr % PAGE_SIZE != 0)
     return -ST_UNALIGNED;
 
-  bool ok = proc_unmap (proc, vaddr, pages);
-  return ok ? ST_OK : -ST_OOM_ERROR;
+  return proc_unmap (proc, vaddr, pages) ? ST_OK : -ST_OOM_ERROR;
 }
 
-/* int proc_create_resource (int rid, int type, int vis, void* buffer) */
-DEFINE_SYSCALL (sys_proc_create_resource) {
+/* int create_mem (int rid, int vis, size_t pages) */
+DEFINE_SYSCALL (sys_create_mem) {
   int rid = (int)a1;
-  int type = (int)a2;
-  int vis = (int)a3;
-  uintptr_t buffer_ptr = a4;
+  int vis = (int)a2;
+  size_t pages = (size_t)a3;
 
-  if (rid < 0)
+  if (!(vis == RV_PUBLIC || vis == RV_PRIVATE))
     return -ST_BAD_RESOURCE;
 
-  if (!(type == PR_MEM || type == PR_MUTEX))
+  if (pages == 0)
+    return ST_OK;
+
+  int rid1 = rid < 0 ? atomic_fetch_add (&proc->resources->sys_rids, 1) : rid;
+
+  struct proc_resource_mem_init mem_init = {.managed = false, .pages = pages};
+  struct proc_resource* mem_resource = proc_create_resource (proc, rid1, PR_MEM, vis, &mem_init);
+
+  if (mem_resource == NULL)
+    return -ST_OOM_ERROR;
+
+  return mem_resource->rid;
+}
+
+/* int unlink_mem (int rid, int vis, size_t pages) */
+DEFINE_SYSCALL (sys_unlink_mem) {
+  spin_lock_ctx_t ctxrs;
+
+  int rid = (int)a1;
+  int vis = (int)a2;
+  size_t pages = (size_t)a3;
+
+  if (!(vis == RV_PUBLIC || vis == RV_PRIVATE))
     return -ST_BAD_RESOURCE;
 
-  if (!(vis == RV_PRIVATE || vis == RV_PUBLIC))
-    return -ST_BAD_RESOURCE;
+  struct proc_resource* mem_resource = proc_find_resource (proc, rid, vis);
 
-  struct resource_buffer* rbuf = NULL;
-  if (buffer_ptr != 0) {
-    rbuf = sys_get_user_buffer (proc, buffer_ptr, sizeof (struct resource_buffer));
-    if (rbuf == NULL)
-      return -ST_BAD_ADDRESS_SPACE;
+  if (mem_resource == NULL)
+    return -ST_NOT_FOUND;
+
+  spin_lock (&mem_resource->lock, &ctxrs);
+
+  if (mem_resource->type != PR_MEM) {
+    spin_unlock (&mem_resource->lock, &ctxrs);
+    return -ST_BAD_RESOURCE;
   }
 
-  /* confusing data is invalid */
-  if ((rbuf != NULL) && (type != rbuf->type))
-    return -ST_BAD_RESOURCE;
-
-  switch (type) {
-  case PR_MEM: {
-    /* need rbuf to construct */
-    if (rbuf == NULL)
-      return -ST_BAD_RESOURCE;
-
-    struct proc_resource_mem_init mem_init = {
-        .managed = false,
-        .pages = rbuf->u.mem.pages,
-    };
-
-    struct proc_resource* resource = proc_create_resource (proc, rid, type, vis, &mem_init);
-
-    if (resource == NULL) {
-      return -ST_OOM_ERROR;
-    }
-
-    rbuf->u.mem.pages = resource->u.mem.pages;
-    rbuf->u.mem.paddr = resource->u.mem.paddr;
-
-    return resource->rid;
-  } break;
-  case PR_MUTEX: {
-    /* no rbuf is fine */
-
-    struct proc_resource* resource = proc_create_resource (proc, rid, type, vis, NULL);
-
-    if (resource == NULL) {
-      return -ST_OOM_ERROR;
-    }
-
-    return resource->rid;
-  } break;
+  mem_resource->u.mem.alive_pages -= pages;
+  if (mem_resource->u.mem.alive_pages < 0) {
+    spin_unlock (&mem_resource->lock, &ctxrs);
+    proc_drop_resource (proc, mem_resource, true);
   }
 
-  assert (0);
-}
-
-/* int proc_mutex_lock (int mutex_rid, int vis) */
-DEFINE_SYSCALL (sys_proc_mutex_lock) {
-  int rid = (int)a1;
-  int vis = (int)a2;
-
-  if (rid < 0)
-    return -ST_BAD_RESOURCE;
-
-  if (!(vis == RV_PUBLIC || vis == RV_PRIVATE))
-    return -ST_BAD_RESOURCE;
-
-  struct proc_resource* resource = proc_find_resource (proc, rid, vis);
-
-  if (resource == NULL)
-    return -ST_NOT_FOUND;
-
-  proc_mutex_lock (proc, &resource->u.mutex);
-
   return ST_OK;
 }
 
-/* int proc_mutex_unlock (int mutex_rid, int vis) */
-DEFINE_SYSCALL (sys_proc_mutex_unlock) {
-  int rid = (int)a1;
-  int vis = (int)a2;
-
-  if (rid < 0)
-    return -ST_BAD_RESOURCE;
-
-  if (!(vis == RV_PUBLIC || vis == RV_PRIVATE))
-    return -ST_BAD_RESOURCE;
-
-  struct proc_resource* resource = proc_find_resource (proc, rid, vis);
-
-  if (resource == NULL)
-    return -ST_NOT_FOUND;
-
-  int result = proc_mutex_unlock (proc, &resource->u.mutex) ? ST_OK : -ST_PERMISSION_ERROR;
-  if (result < 0)
-    return result;
-
-  return ST_OK;
-}
-
-/* int proc_drop_resource (int rid, int vis) */
-DEFINE_SYSCALL (sys_proc_drop_resource) {
-  int rid = (int)a1;
-  int vis = (int)a2;
-
-  if (rid < 0)
-    return -ST_BAD_RESOURCE;
-
-  if (!(vis == RV_PUBLIC || vis == RV_PRIVATE))
-    return -ST_BAD_RESOURCE;
-
-  struct proc_resource* resource = proc_find_resource (proc, rid, vis);
-
-  if (resource == NULL)
-    return -ST_NOT_FOUND;
-
-  proc_drop_resource (proc, resource, true);
-
-  return ST_OK;
-}
-
-/* int proc_clone (uintptr_t vstack_top, size_t stack_size, void* entry) */
-DEFINE_SYSCALL (sys_proc_clone) {
+/* int clone (uintptr_t vstack_top, size_t stack_size, void* entry) */
+DEFINE_SYSCALL (sys_clone) {
   uintptr_t vstack_top = a1;
   size_t stack_size = (size_t)a2;
   uintptr_t entry = a3;
@@ -236,46 +178,20 @@ DEFINE_SYSCALL (sys_proc_clone) {
 }
 
 /* int proc_sched (void) */
-DEFINE_SYSCALL (sys_proc_sched) {
+DEFINE_SYSCALL (sys_sched) {
   proc_sched (regs);
   return ST_OK;
 }
 
-/* int proc_translate_v2p (uintptr_t vaddr, uintptr_t* out_paddr) */
-DEFINE_SYSCALL (sys_proc_translate_v2p) {
-  int result = ST_OK;
-
-  uintptr_t vaddr = a1;
-  uintptr_t out_paddr_buf = a2;
-
-  uintptr_t* out_paddr_buf_vaddr = sys_get_user_buffer (proc, out_paddr_buf, sizeof (uintptr_t));
-  if (out_paddr_buf_vaddr == NULL)
-    return -ST_BAD_ADDRESS_SPACE;
-
-  uintptr_t translated_addr = mm_v2p (proc->pd, vaddr, MM_PD_LOCK);
-  if (translated_addr == 0) {
-    result = -ST_BAD_ADDRESS_SPACE;
-    goto done;
-  }
-
-  *out_paddr_buf_vaddr = translated_addr;
-
-done:
-  return result;
-}
-
 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,
-    [SYS_PROC_CREATE_RESOURCE] = &sys_proc_create_resource,
-    [SYS_PROC_DROP_RESOURCE] = &sys_proc_drop_resource,
-    [SYS_PROC_MUTEX_LOCK] = &sys_proc_mutex_lock,
-    [SYS_PROC_MUTEX_UNLOCK] = &sys_proc_mutex_unlock,
-    [SYS_PROC_CLONE] = &sys_proc_clone,
-    [SYS_PROC_SCHED] = &sys_proc_sched,
-    [SYS_PROC_TRANSLATE_V2P] = &sys_proc_translate_v2p,
+    [SYS_QUIT] = &sys_quit,
+    [SYS_TEST] = &sys_test,
+    [SYS_MAP] = &sys_map,
+    [SYS_UNMAP] = &sys_unmap,
+    [SYS_CLONE] = &sys_clone,
+    [SYS_SCHED] = &sys_sched,
+    [SYS_CREATE_MEM] = &sys_create_mem,
+    [SYS_UNLINK_MEM] = &sys_unlink_mem,
 };
 
 syscall_handler_func_t syscall_find_handler (int syscall_num) {