Implement proc_spawn_thread syscall, fix proc_resume and proc_suspend

include/m/syscall_defs.h

@@ -10,6 +10,8 @@
 #define SYS_PROC_CREATE_RESOURCE_MUTEX  7
 #define SYS_PROC_MUTEX_LOCK             8
 #define SYS_PROC_MUTEX_UNLOCK           9
+#define SYS_PROC_SPAWN_THREAD           10
+#define SYS_PROC_SCHED                  11
 
 #define SR_OK                0
 #define SR_SYSCALL_NOT_FOUND 1

init/init.c

@@ -5,24 +5,41 @@
 #include <string/string.h>
 
 char c = 'a';
+int mutex_rid;
 
-void app_main (void) {
-  uintptr_t out_paddr;
-  int mem_rid = proc_create_resource_mem (100, 16, RV_PRIVATE, &out_paddr);
-
-  proc_map (out_paddr, PROC_MAP_BASE, 16, PM_PRESENT | PM_RW | PM_USER);
-
-  memset ((void*)PROC_MAP_BASE, 0, PAGE_SIZE * 16);
-
-  proc_unmap (PROC_MAP_BASE, 16);
-
-  proc_drop_resource (mem_rid);
-
-  proc_test ('a');
-
-  int mutex_rid = proc_create_resource_mutex (101, RV_PRIVATE);
-
+void mythread (void) {
+  for (;;) {
     proc_mutex_lock (mutex_rid);
+    for (size_t i = 0; i < 3; i++)
       proc_test ('b');
     proc_mutex_unlock (mutex_rid);
+    proc_sched ();
+  }
+}
+
+void make_thread (void* fn) {
+  size_t stack_pages = 256;
+  size_t stack_size = PAGE_SIZE * stack_pages;
+
+  uintptr_t out_paddr;
+  int mem_rid = proc_create_resource_mem (100, stack_pages, RV_PRIVATE, &out_paddr);
+  proc_map (out_paddr, PROC_MAP_BASE, stack_pages, PM_PRESENT | PM_RW | PM_USER);
+  memset ((void*)PROC_MAP_BASE, 0, stack_size);
+
+  uintptr_t vstack_top = PROC_MAP_BASE + stack_size;
+  proc_spawn_thread (vstack_top, stack_size, fn);
+}
+
+void app_main (void) {
+  mutex_rid = proc_create_resource_mutex (200, RV_PRIVATE);
+
+  make_thread (&mythread);
+
+  for (;;) {
+    proc_mutex_lock (mutex_rid);
+    for (size_t i = 0; i < 3; i++)
+      proc_test ('a');
+    proc_mutex_unlock (mutex_rid);
+    proc_sched ();
+  }
 }

kernel/amd64/mm.c

@@ -11,12 +11,10 @@
 #include <sys/mm.h>
 #include <sys/smp.h>
 
-/* Present flag */
 #define AMD64_PG_PRESENT (1 << 0)
-/* Writable flag */
 #define AMD64_PG_RW      (1 << 1)
-/* User-accessible flag */
 #define AMD64_PG_USER    (1 << 2)
+#define AMD64_PG_HUGE    (1 << 7)
 
 /* Auxilary struct for page directory walking */
 struct pg_index {
@@ -64,9 +62,12 @@ static uint64_t* amd64_mm_next_table (uint64_t* table, uint64_t entry_idx, bool
 
   struct limine_hhdm_response* hhdm = limine_hhdm_request.response;
 
-  if (entry & AMD64_PG_PRESENT)
+  if (entry & AMD64_PG_PRESENT) {
+    if (entry & AMD64_PG_HUGE)
+      return NULL;
+
     paddr = entry & ~0xFFFULL;
-  else {
+  } else {
     if (!alloc)
       return NULL;
 

kernel/amd64/proc.c

@@ -33,6 +33,14 @@ struct proc* proc_from_elf (uint8_t* elf_contents) {
     return NULL;
   }
 
+  proc->sys_rids = malloc (sizeof (*proc->sys_rids));
+  if (proc->sys_rids == NULL) {
+    free (proc);
+    return NULL;
+  }
+  proc->sys_rids->counter = 0;
+  proc->sys_rids->refs = 1;
+
   proc->pd->lock = SPIN_LOCK_INIT;
   proc->pd->refs = 1;
   proc->pd->cr3_paddr = mm_alloc_user_pd_phys ();
@@ -42,9 +50,10 @@ struct proc* proc_from_elf (uint8_t* elf_contents) {
     return NULL;
   }
 
+  int kstk_rid = atomic_fetch_add (&proc->sys_rids->counter, 1);
   struct proc_resource_mem_init kstk_mem_init = {.pages = KSTACK_SIZE / PAGE_SIZE};
   struct proc_resource* kstk_r =
-      proc_create_resource (proc, 0, PR_MEM, RV_PRIVATE, (void*)&kstk_mem_init);
+      proc_create_resource (proc, kstk_rid, PR_MEM, RV_PRIVATE, (void*)&kstk_mem_init);
   if (kstk_r == NULL) {
     pmm_free (proc->pd->cr3_paddr, 1);
     free (proc->pd);
@@ -54,9 +63,10 @@ struct proc* proc_from_elf (uint8_t* elf_contents) {
 
   proc->pdata.kernel_stack = kstk_r->u.mem.paddr + (uintptr_t)hhdm->offset + KSTACK_SIZE;
 
+  int ustk_rid = atomic_fetch_add (&proc->sys_rids->counter, 1);
   struct proc_resource_mem_init ustk_mem_init = {.pages = USTACK_SIZE / PAGE_SIZE};
   struct proc_resource* ustk_r =
-      proc_create_resource (proc, 1, PR_MEM, RV_PRIVATE, (void*)&ustk_mem_init);
+      proc_create_resource (proc, ustk_rid, PR_MEM, RV_PRIVATE, (void*)&ustk_mem_init);
   if (ustk_r == NULL) {
     kstk_r->ops.cleanup (proc, kstk_r);
     free (kstk_r);
@@ -71,6 +81,8 @@ struct proc* proc_from_elf (uint8_t* elf_contents) {
   proc_map (proc, proc->pdata.user_stack, PROC_USTACK_TOP - USTACK_SIZE, USTACK_SIZE / PAGE_SIZE,
             MM_PG_USER | MM_PG_PRESENT | MM_PG_RW);
 
+  proc->flags |= PROC_USTK_PREALLOC;
+
   struct elf_aux aux = proc_load_segments (proc, elf_contents);
 
   proc->pdata.regs.ss = GDT_UDATA | 0x03;
@@ -82,6 +94,63 @@ 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 limine_hhdm_response* hhdm = limine_hhdm_request.response;
+  spin_lock_ctx_t ctxprt;
+
+  struct proc* proc = malloc (sizeof (*proc));
+  if (proc == NULL)
+    return NULL;
+
+  memset (proc, 0, sizeof (*proc));
+
+  proc->lock = SPIN_LOCK_INIT;
+  atomic_store (&proc->state, PROC_READY);
+  proc->pid = atomic_fetch_add (&pids, 1);
+
+  spin_lock (&proto->lock, &ctxprt);
+
+  proc->pd = proto->pd;
+  proc->mappings = proto->mappings;
+  atomic_fetch_add (&proto->pd->refs, 1);
+
+  proc->resource_tree = proto->resource_tree;
+  proc->sys_rids = proto->sys_rids;
+  atomic_fetch_add (&proc->sys_rids->refs, 1);
+
+  spin_unlock (&proto->lock, &ctxprt);
+
+  uintptr_t vstack_bottom = vstack_top - stack_size;
+
+  uintptr_t pstack_bottom = mm_v2p (proc->pd, vstack_bottom, MM_PD_LOCK);
+  if (pstack_bottom == 0) {
+    free (proc);
+    return NULL;
+  }
+
+  int kstk_rid = atomic_fetch_add (&proc->sys_rids->counter, 1);
+  struct proc_resource_mem_init kstk_mem_init = {.pages = KSTACK_SIZE / PAGE_SIZE};
+  struct proc_resource* kstk_r =
+      proc_create_resource (proc, kstk_rid, PR_MEM, RV_PRIVATE, (void*)&kstk_mem_init);
+  if (kstk_r == NULL) {
+    free (proc);
+    return NULL;
+  }
+
+  proc->pdata.kernel_stack = kstk_r->u.mem.paddr + (uintptr_t)hhdm->offset + KSTACK_SIZE;
+
+  proc->pdata.user_stack = pstack_bottom + stack_size;
+
+  proc->pdata.regs.ss = GDT_UDATA | 0x03;
+  proc->pdata.regs.rsp = (uint64_t)vstack_top;
+  proc->pdata.regs.rflags = 0x202;
+  proc->pdata.regs.cs = GDT_UCODE | 0x03;
+  proc->pdata.regs.rip = (uint64_t)entry;
+
+  return proc;
+}
+
 void proc_cleanup (struct proc* proc) {
   struct limine_hhdm_response* hhdm = limine_hhdm_request.response;
   spin_lock_ctx_t ctxprpd;
@@ -108,7 +177,10 @@ void proc_cleanup (struct proc* proc) {
 
   pmm_free (proc->pdata.kernel_stack - (uintptr_t)hhdm->offset - KSTACK_SIZE,
             KSTACK_SIZE / PAGE_SIZE);
+
+  if ((proc->flags & PROC_USTK_PREALLOC))
     pmm_free (proc->pdata.user_stack, USTACK_SIZE / PAGE_SIZE);
+
   DEBUG ("PID %d Free stacks\n", proc->pid);
 
   free (proc);

kernel/proc/mutex.c

@@ -7,36 +7,58 @@
 #include <sys/debug.h>
 
 void proc_mutex_lock (struct proc* proc, struct proc_mutex* mutex) {
-  while (atomic_flag_test_and_set_explicit (&mutex->flag, memory_order_acquire))
+  spin_lock_ctx_t ctxmt;
+
+try:
+  spin_lock (&mutex->lock, &ctxmt);
+
+  if (!mutex->locked || mutex->owner == proc) {
+    mutex->locked = true;
+    mutex->owner = proc;
+    spin_unlock (&mutex->lock, &ctxmt);
+    return;
+  }
+
+  spin_unlock (&mutex->lock, &ctxmt);
+
   proc_suspend (proc, &mutex->suspension_q);
 
-  /* taken */
-
-  mutex->owner = proc;
+  goto try;
 }
 
 bool proc_mutex_unlock (struct proc* proc, struct proc_mutex* mutex) {
-  if (mutex->owner != proc)
-    return false;
+  spin_lock_ctx_t ctxmt, ctxsq;
 
-  atomic_flag_clear_explicit (&mutex->flag, memory_order_release);
+  spin_lock (&mutex->lock, &ctxmt);
+
+  if (mutex->owner != proc) {
+    spin_unlock (&mutex->lock, &ctxmt);
+    return false;
+  }
+
+  spin_lock (&mutex->suspension_q.lock, &ctxsq);
 
   struct proc* resumed_proc;
   struct rb_node_link* node;
   rbtree_first (&mutex->suspension_q.proc_tree, node);
 
-  while (node) {
-    struct rb_node_link* next;
-    rbtree_next (node, next);
-
+  if (node) {
     resumed_proc = rbtree_entry (node, struct proc, suspension_link);
+    mutex->owner = resumed_proc;
 
+    spin_unlock (&mutex->suspension_q.lock, &ctxsq);
+    spin_unlock (&mutex->lock, &ctxmt);
     proc_resume (resumed_proc);
 
-    node = next;
+    return true;
   }
 
-  assert (mutex->suspension_q.proc_tree == NULL);
+  spin_unlock (&mutex->suspension_q.lock, &ctxsq);
+
+  mutex->locked = false;
+  mutex->owner = NULL;
+
+  spin_unlock (&mutex->lock, &ctxmt);
 
   return true;
 }

kernel/proc/mutex.h

@@ -8,7 +8,8 @@
 struct proc;
 
 struct proc_mutex {
-  atomic_flag flag;
+  spin_lock_t lock;
+  bool locked;
   struct proc_suspension_q suspension_q;
   struct proc* owner;
 };

kernel/proc/proc.c

@@ -197,7 +197,7 @@ static struct proc* proc_spawn_rd (char* name) {
   return proc_from_elf (rd_file->content);
 }
 
-static void proc_register (struct proc* proc, struct cpu* cpu) {
+void proc_register (struct proc* proc, struct cpu* cpu) {
   spin_lock_ctx_t ctxcpu, ctxprtr;
 
   proc->cpu = cpu;

kernel/proc/proc.h

@@ -25,6 +25,8 @@
 
 #define PROC_RESOURCES_MAX 1024
 
+#define PROC_USTK_PREALLOC (1 << 0)
+
 struct cpu;
 
 struct proc_mapping {
@@ -35,6 +37,11 @@ struct proc_mapping {
   size_t size;
 };
 
+struct proc_sys_rids {
+  atomic_int refs;
+  atomic_int counter;
+};
+
 struct proc {
   int pid;
   struct rb_node_link proc_tree_link;
@@ -44,11 +51,13 @@ struct proc {
 
   struct list_node_link* mappings; /* pd.lock implicitly protects this field */
   struct proc_platformdata pdata;
+  uint32_t flags;
   struct pd* pd;
   spin_lock_t lock;
   struct cpu* cpu;
   atomic_int state;
   struct rb_node_link* resource_tree;
+  struct proc_sys_rids* sys_rids;
   struct proc_suspension_q* suspension_q;
 };
 
@@ -60,6 +69,7 @@ bool proc_map (struct proc* proc, uintptr_t start_paddr, uintptr_t start_vaddr,
                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_register (struct proc* proc, struct cpu* cpu);
 void proc_init (void);
 
 #endif // _KERNEL_PROC_PROC_H

kernel/sys/proc.h

@@ -6,6 +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);
 void proc_cleanup (struct proc* proc);
 
 #endif // _KERNEL_SYS_PROC_H

kernel/syscall/syscall.c

@@ -9,6 +9,7 @@
 #include <sync/spin_lock.h>
 #include <sys/debug.h>
 #include <sys/mm.h>
+#include <sys/proc.h>
 #include <syscall/syscall.h>
 
 #define DEFINE_SYSCALL(name)                                                                       \
@@ -24,7 +25,7 @@ DEFINE_SYSCALL (sys_proc_quit) {
 /* int proc_test (void) */
 DEFINE_SYSCALL (sys_proc_test) {
   char c = (char)a1;
-  DEBUG ("test syscall! %c\n", c);
+  DEBUG ("test syscall from %d! %c\n", proc->pid, c);
   return SR_OK;
 }
 
@@ -163,6 +164,35 @@ DEFINE_SYSCALL (sys_proc_drop_resource) {
   return SR_OK;
 }
 
+/* int proc_spawn_thread (uintptr_t vstack_top, size_t stack_size, void* entry) */
+DEFINE_SYSCALL (sys_proc_spawn_thread) {
+  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);
+
+  DEBUG ("new=%p\n", new);
+
+  if (new == NULL) {
+    return -SR_OOM_ERROR;
+  }
+
+  int pid = new->pid;
+
+  proc_register (new, cpu);
+
+  return pid;
+}
+
+/* int proc_sched (void) */
+DEFINE_SYSCALL (sys_proc_sched) {
+  proc_sched (regs);
+  return SR_OK;
+}
+
 static syscall_handler_func_t handler_table[] = {
     [SYS_PROC_QUIT] = &sys_proc_quit,
     [SYS_PROC_TEST] = &sys_proc_test,
@@ -173,6 +203,8 @@ static syscall_handler_func_t handler_table[] = {
     [SYS_PROC_CREATE_RESOURCE_MUTEX] = &sys_proc_create_resource_mutex,
     [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,
 };
 
 syscall_handler_func_t syscall_find_handler (int syscall_num) {

libmsl/m/proc.c

@@ -35,3 +35,10 @@ int proc_mutex_lock (int mutex_rid) {
 int proc_mutex_unlock (int mutex_rid) {
   return syscall (SYS_PROC_MUTEX_UNLOCK, (uintptr_t)mutex_rid, 0, 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_sched (void) { return syscall (SYS_PROC_SCHED, 0, 0, 0, 0, 0, 0); }

libmsl/m/proc.h

@@ -25,5 +25,7 @@ int proc_drop_resource (int rid);
 int proc_create_resource_mutex (int rid, int vis);
 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);
 
 #endif // _LIBMSL_M_PROC_H