Redesign syscalls

include/m/resource_buffer.h

@@ -1,19 +0,0 @@
-#ifndef _M_RESOURCE_BUFFER_H
-#define _M_RESOURCE_BUFFER_H
-
-#include <stdint.h>
-#include <stddef.h>
-
-struct resource_buffer_mem {
-  uintptr_t paddr;
-  size_t pages;
-};
-
-struct resource_buffer {
-  int type;
-  union {
-    struct resource_buffer_mem mem;
-  } u;
-};
-
-#endif // _M_RESOURCE_BUFFER_H

include/m/syscall_defs.h

@@ -1,16 +1,13 @@
 #ifndef _M_SYSCALL_DEFS_H
 #define _M_SYSCALL_DEFS_H
 
-#define SYS_PROC_QUIT                   1
-#define SYS_PROC_TEST                   2
-#define SYS_PROC_MAP                    3
-#define SYS_PROC_UNMAP                  4
-#define SYS_PROC_CREATE_RESOURCE        5
-#define SYS_PROC_DROP_RESOURCE          6
-#define SYS_PROC_MUTEX_LOCK             8
-#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_QUIT          1
+#define SYS_TEST          2
+#define SYS_MAP           3
+#define SYS_UNMAP         4
+#define SYS_CLONE         5
+#define SYS_SCHED         6
+#define SYS_CREATE_MEM    7
+#define SYS_UNLINK_MEM    8
 
 #endif // _M_SYSCALL_DEFS_H

init/init.c

@@ -1,7 +1,7 @@
 #include <alloc/liballoc.h>
 #include <limits.h>
-#include <m/proc.h>
 #include <m/status.h>
+#include <m/system.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <string/string.h>
@@ -9,52 +9,17 @@
 #define EXAMPLE 1
 
 #if EXAMPLE == 1
-int mutex_rid;
-
-void mythread (void) {
-  for (int j = 0; j < 10; j++) {
-    proc_mutex_lock (mutex_rid, RV_PRIVATE);
-
-    for (size_t i = 0; i < 3; i++)
-      proc_test ('b');
-
-    proc_mutex_unlock (mutex_rid, RV_PRIVATE);
-
-    for (volatile int i = 0; i < 200 * 1000 * 1000; i++)
-      ;
-  }
-
-  proc_quit ();
-}
-
-int make_thread (void (*fn) (void)) {
-  size_t stack_size = 256 * PAGE_SIZE;
-  void* stack = malloc (stack_size);
-  if (stack == NULL)
-    return -ST_OOM_ERROR;
-
-  uintptr_t stack_top = (uintptr_t)stack + stack_size;
-  return proc_spawn_thread (stack_top, stack_size, (void*)fn);
-}
-
 void app_main (void) {
-  mutex_rid = proc_create_resource (200, PR_MUTEX, RV_PRIVATE, NULL);
+  test ('a');
+  test ('a');
+  test ('a');
 
-  make_thread (&mythread);
+  int* xs = malloc (1024 * sizeof (*xs));
+  memset (xs, 123, 1024 * sizeof (*xs));
+  free (xs);
 
-  for (int j = 0; j < 10; j++) {
-    proc_mutex_lock (mutex_rid, RV_PRIVATE);
-
-    for (size_t i = 0; i < 3; i++)
-      proc_test ('a');
-
-    proc_mutex_unlock (mutex_rid, RV_PRIVATE);
-
-    for (volatile int i = 0; i < 400 * 1000 * 1000; i++)
-      ;
-  }
-
-  for (;;)
-    ;
+  test ('a');
+  test ('a');
+  test ('a');
 }
 #endif

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/amd64/proc.c

@@ -106,8 +106,8 @@ struct proc* proc_from_elf (uint8_t* elf_contents) {
   return proc;
 }
 
-struct proc* proc_spawn_thread (struct proc* proto, uintptr_t vstack_top, size_t stack_size,
-                                uintptr_t entry) {
+struct proc* proc_clone (struct proc* proto, uintptr_t vstack_top, size_t stack_size,
+                         uintptr_t entry) {
   struct limine_hhdm_response* hhdm = limine_hhdm_request.response;
   spin_lock_ctx_t ctxprt, ctxrs;
   int rid;

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/sys/proc.h

@@ -6,8 +6,8 @@
 struct proc;
 
 struct proc* proc_from_elf (uint8_t* elf_contents);
-struct proc* proc_spawn_thread (struct proc* proto, uintptr_t vstack_top, size_t stack_size,
-                                uintptr_t entry);
+struct proc* proc_clone (struct proc* proto, uintptr_t vstack_top, size_t stack_size,
+                         uintptr_t entry);
 void proc_cleanup (struct proc* proc);
 
 #endif // _KERNEL_SYS_PROC_H

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,187 +39,130 @@ 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_spawn_thread (uintptr_t vstack_top, size_t stack_size, void* entry) */
-DEFINE_SYSCALL (sys_proc_spawn_thread) {
+/* 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;
 
   struct cpu* cpu = proc->cpu;
 
-  struct proc* new = proc_spawn_thread (proc, vstack_top, stack_size, entry);
+  struct proc* new = proc_clone (proc, vstack_top, stack_size, entry);
 
   DEBUG ("new=%p\n", new);
 
@@ -236,46 +178,20 @@ DEFINE_SYSCALL (sys_proc_spawn_thread) {
 }
 
 /* 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_SPAWN_THREAD] = &sys_proc_spawn_thread,
-    [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) {

libmsl/alloc/liballoc.c

@@ -2,37 +2,29 @@
 #pragma clang optimize off
 
 #include <alloc/liballoc.h>
-#include <m/proc.h>
-#include <m/resource_buffer.h>
+#include <m/system.h>
 
-static int liballoc_mutex;
 static uintptr_t liballoc_map_base = PROC_MAP_BASE;
 static int mem_rid_base = 1000000;
 
-void liballoc_init (void) {
-  liballoc_mutex = proc_create_resource (100, PR_MUTEX, RV_PRIVATE, NULL);
-}
+void liballoc_init (void) {}
 
-int liballoc_lock (void) {
-  proc_mutex_lock (liballoc_mutex, RV_PRIVATE);
-  return 0;
-}
+int liballoc_lock (void) { return 0; }
 
-int liballoc_unlock (void) {
-  proc_mutex_unlock (liballoc_mutex, RV_PRIVATE);
-  return 0;
-}
+int liballoc_unlock (void) { return 0; }
 
-void* liballoc_alloc (int pages) {
+void* liballoc_alloc (int pages, int* mem_rid) {
   uintptr_t current_base = liballoc_map_base;
 
-  struct resource_buffer mem_init = {.type = PR_MEM, .u = {.mem = {.pages = (size_t)pages}}};
-
-  int mem_rid = proc_create_resource (mem_rid_base++, PR_MEM, RV_PRIVATE, &mem_init);
-  if (mem_rid < 0)
+  *mem_rid = create_mem (mem_rid_base++, RV_PRIVATE, pages);
+  if (*mem_rid < 0) {
     return NULL;
+  }
 
-  proc_map (mem_init.u.mem.paddr, current_base, (size_t)pages, PM_PRESENT | PM_RW | PM_USER);
+  if (map (*mem_rid, RV_PRIVATE, current_base, MAP_FLAGS | MAP_RW) < 0) {
+    unlink_mem (*mem_rid, RV_PRIVATE, pages);
+    return NULL;
+  }
 
   uintptr_t old_base = current_base;
   current_base += pages * PAGE_SIZE;
@@ -40,7 +32,11 @@ 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 mem_rid) {
+  unmap ((uintptr_t)ptr, pages);
+  unlink_mem (mem_rid, RV_PRIVATE, pages);
+  return 0;
+}
 
 /**  Durand's Ridiculously Amazing Super Duper Memory functions.  */
 
@@ -207,6 +203,7 @@ static struct boundary_tag* allocate_new_tag (unsigned int size) {
   unsigned int pages;
   unsigned int usage;
   struct boundary_tag* tag;
+  int mem_rid;
 
   // This is how much space is required.
   usage = size + sizeof (struct boundary_tag);
@@ -220,7 +217,7 @@ static struct boundary_tag* allocate_new_tag (unsigned int size) {
   if (pages < (unsigned int)l_pageCount)
     pages = l_pageCount;
 
-  tag = (struct boundary_tag*)liballoc_alloc (pages);
+  tag = (struct boundary_tag*)liballoc_alloc (pages, &mem_rid);
 
   if (tag == NULL)
     return NULL; // uh oh, we ran out of memory.
@@ -229,6 +226,7 @@ static struct boundary_tag* allocate_new_tag (unsigned int size) {
   tag->size = size;
   tag->real_size = pages * l_pageSize;
   tag->index = -1;
+  tag->mem_rid = mem_rid;
 
   tag->next = NULL;
   tag->prev = NULL;
@@ -351,7 +349,7 @@ void free (void* ptr) {
       if (pages < (unsigned int)l_pageCount)
         pages = l_pageCount;
 
-      liballoc_free (tag, pages);
+      liballoc_free (tag, pages, tag->mem_rid);
 
       liballoc_unlock ();
       return;

libmsl/alloc/liballoc.h

@@ -41,6 +41,8 @@ struct boundary_tag {
 
   struct boundary_tag* next; //< Linked list info.
   struct boundary_tag* prev; //< Linked list info.
+
+  int mem_rid;
 };
 
 /** This function is supposed to lock the memory data structures. It
@@ -67,7 +69,7 @@ extern int liballoc_unlock (void);
  * \return NULL if the pages were not allocated.
  * \return A pointer to the allocated memory.
  */
-extern void* liballoc_alloc (int);
+extern void* liballoc_alloc (int pages, int* mem_rid);
 
 /** This frees previously allocated memory. The void* parameter passed
  * to the function is the exact same value returned from a previous
@@ -77,7 +79,7 @@ extern void* liballoc_alloc (int);
  *
  * \return 0 if the memory was successfully freed.
  */
-extern int liballoc_free (void*, int);
+extern int liballoc_free (void* ptr, int pages, int mem_rid);
 
 void* malloc (size_t);         //< The standard function.
 void* realloc (void*, size_t); //< The standard function.

libmsl/init/__premain.c

@@ -1,5 +1,5 @@
 #include <alloc/liballoc.h>
-#include <m/proc.h>
+#include <m/system.h>
 #include <stdint.h>
 
 extern volatile uint8_t __bss_start[];
@@ -20,5 +20,5 @@ void __premain (void) {
 
   app_main ();
 
-  proc_quit ();
+  quit ();
 }

libmsl/m/proc.c

@@ -1,45 +0,0 @@
-#include <m/resource_buffer.h>
-#include <m/syscall.h>
-#include <m/syscall_defs.h>
-#include <stddef.h>
-#include <stdint.h>
-
-int proc_quit (void) { return syscall (SYS_PROC_QUIT, 0, 0, 0, 0, 0, 0); }
-
-int proc_test (char c) { return syscall (SYS_PROC_TEST, (uintptr_t)c, 0, 0, 0, 0, 0); }
-
-int proc_map (uintptr_t paddr, uintptr_t vaddr, size_t pages, uint32_t flags) {
-  return syscall (SYS_PROC_MAP, paddr, vaddr, (uintptr_t)pages, (uintptr_t)flags, 0, 0);
-}
-
-int proc_unmap (uintptr_t vaddr, size_t pages) {
-  return syscall (SYS_PROC_UNMAP, vaddr, (uintptr_t)pages, 0, 0, 0, 0);
-}
-
-int proc_create_resource (int rid, int type, int vis, void* buffer) {
-  return syscall (SYS_PROC_CREATE_RESOURCE, (uintptr_t)rid, (uintptr_t)type, (uintptr_t)vis,
-                  (uintptr_t)buffer, 0, 0);
-}
-
-int proc_drop_resource (int rid, int vis) {
-  return syscall (SYS_PROC_DROP_RESOURCE, (uintptr_t)rid, (uintptr_t)vis, 0, 0, 0, 0);
-}
-
-int proc_mutex_lock (int mutex_rid, int vis) {
-  return syscall (SYS_PROC_MUTEX_LOCK, (uintptr_t)mutex_rid, (uintptr_t)vis, 0, 0, 0, 0);
-}
-
-int proc_mutex_unlock (int mutex_rid, int vis) {
-  return syscall (SYS_PROC_MUTEX_UNLOCK, (uintptr_t)mutex_rid, (uintptr_t)vis, 0, 0, 0, 0);
-}
-
-int proc_spawn_thread (uintptr_t vstack_top, size_t stack_size, void* entry) {
-  return syscall (SYS_PROC_SPAWN_THREAD, vstack_top, (uintptr_t)stack_size, (uintptr_t)entry, 0, 0,
-                  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_sched (void) { return syscall (SYS_PROC_SCHED, 0, 0, 0, 0, 0, 0); }

libmsl/m/proc.h

@@ -1,34 +0,0 @@
-#ifndef _LIBMSL_M_PROC_H
-#define _LIBMSL_M_PROC_H
-
-#if defined(__x86_64__)
-#define PROC_MAP_BASE 0x0000700000000000
-#define PAGE_SIZE     4096
-#endif
-
-#define PM_PRESENT (1 << 0)
-#define PM_RW      (1 << 1)
-#define PM_USER    (1 << 2)
-
-#define RV_PRIVATE 0
-#define RV_PUBLIC  1
-
-#define PR_MEM   0
-#define PR_MUTEX 1
-
-#include <stddef.h>
-#include <stdint.h>
-
-int proc_quit (void);
-int proc_test (char c);
-int proc_map (uintptr_t paddr, uintptr_t vaddr, size_t pages, uint32_t flags);
-int proc_unmap (uintptr_t vaddr, size_t pages);
-int proc_create_resource (int rid, int type, int vis, void* buffer);
-int proc_drop_resource (int rid, int vis);
-int proc_mutex_lock (int mutex_rid, int vis);
-int proc_mutex_unlock (int mutex_rid, int vis);
-int proc_spawn_thread (uintptr_t vstack_top, size_t stack_size, void* entry);
-int proc_sched (void);
-int proc_translate_v2p (uintptr_t vaddr, uintptr_t* out_paddr);
-
-#endif // _LIBMSL_M_PROC_H

libmsl/m/src.mk

@@ -1,3 +1,3 @@
-c += m/proc.c
+c += m/system.c
 
-o += m/proc.o
+o += m/system.o

libmsl/m/system.c

@@ -0,0 +1,32 @@
+#include <m/syscall.h>
+#include <m/system.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#define do_syscall1(id, a1, a2, a3, a4, a5, a6, ...)                                               \
+  syscall (id, (uintptr_t)a1, (uintptr_t)a2, (uintptr_t)a3, (uintptr_t)a4, (uintptr_t)a5,          \
+           (uintptr_t)a6)
+
+#define do_syscall(...) do_syscall1 (__VA_ARGS__, 0, 0, 0, 0, 0, 0)
+
+int quit (void) { return do_syscall (SYS_QUIT); }
+
+int test (char c) { return do_syscall (SYS_TEST, c); }
+
+int map (int mem_rid, int vis, uintptr_t vaddr, uint32_t flags) {
+  return do_syscall (SYS_MAP, mem_rid, vis, vaddr, flags);
+}
+
+int unmap (uintptr_t vaddr, size_t pages) { return do_syscall (SYS_UNMAP, vaddr, pages); }
+
+int create_mem (int mem_rid, int vis, size_t pages) {
+  return do_syscall (SYS_CREATE_MEM, mem_rid, vis, pages);
+}
+
+int unlink_mem (int mem_rid, int vis, size_t pages) {
+  return do_syscall (SYS_UNLINK_MEM, mem_rid, vis, pages);
+}
+
+int clone (uintptr_t vstack_top, size_t stack_size, void (*entry) (void)) {
+  return do_syscall (SYS_CLONE, vstack_top, stack_size, entry);
+}

libmsl/m/system.h

@@ -0,0 +1,28 @@
+#ifndef _LIBMSL_M_SYSTEM_H
+#define _LIBMSL_M_SYSTEM_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#if defined(__x86_64__)
+#define PROC_MAP_BASE 0x0000700000000000
+#define PAGE_SIZE     4096
+#endif
+
+#define MAP_PRESENT (1 << 0)
+#define MAP_RW      (1 << 1)
+#define MAP_USER    (1 << 2)
+#define MAP_FLAGS   (MAP_PRESENT | MAP_USER)
+
+#define RV_PRIVATE 0
+#define RV_PUBLIC  1
+
+int quit (void);
+int test (char c);
+int map (int mem_rid, int vis, uintptr_t vaddr, uint32_t flags);
+int unmap (uintptr_t vaddr, size_t pages);
+int create_mem (int mem_rid, int vis, size_t pages);
+int unlink_mem (int mem_rid, int vis, size_t pages);
+int clone (uintptr_t vstack_top, size_t stack_size, void (*entry) (void));
+
+#endif // _LIBMSL_M_SYSTEM_H