Implement Mutexes and supporting syscalls, cleanup/optimize scheduler

kernel/proc/mutex.c

@@ -0,0 +1,42 @@
+#include <libk/assert.h>
+#include <libk/rbtree.h>
+#include <libk/std.h>
+#include <proc/mutex.h>
+#include <proc/proc.h>
+#include <sync/spin_lock.h>
+#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))
+    proc_suspend (proc, &mutex->suspension_q);
+
+  /* taken */
+
+  mutex->owner = proc;
+}
+
+bool proc_mutex_unlock (struct proc* proc, struct proc_mutex* mutex) {
+  if (mutex->owner != proc)
+    return false;
+
+  atomic_flag_clear_explicit (&mutex->flag, memory_order_release);
+
+  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);
+
+    resumed_proc = rbtree_entry (node, struct proc, suspension_link);
+
+    proc_resume (resumed_proc);
+
+    node = next;
+  }
+
+  assert (mutex->suspension_q.proc_tree == NULL);
+
+  return true;
+}

kernel/proc/mutex.h

@@ -0,0 +1,19 @@
+#ifndef _KERNEL_PROC_MUTEX_H
+#define _KERNEL_PROC_MUTEX_H
+
+#include <libk/std.h>
+#include <proc/suspension_q.h>
+#include <sync/spin_lock.h>
+
+struct proc;
+
+struct proc_mutex {
+  atomic_flag flag;
+  struct proc_suspension_q suspension_q;
+  struct proc* owner;
+};
+
+void proc_mutex_lock (struct proc* proc, struct proc_mutex* mutex);
+bool proc_mutex_unlock (struct proc* proc, struct proc_mutex* mutex);
+
+#endif // _KERNEL_PROC_MUTEX_H

kernel/proc/proc.c

@@ -25,6 +25,8 @@
 #include <amd64/intr_defs.h>
 #endif
 
+#define SCHED_REAP_FREQ 200
+
 /*
  * Lock hierachy:
  * - proc_tree_lock
@@ -36,6 +38,8 @@
 static struct rb_node_link* proc_tree = NULL;
 static rw_spin_lock_t proc_tree_lock = RW_SPIN_LOCK_INIT;
 
+static atomic_int sched_cycles = 0;
+
 static bool proc_check_elf (uint8_t* elf) {
   if (!((elf[0] == 0x7F) && (elf[1] == 'E') && (elf[2] == 'L') && (elf[3] == 'F')))
     return false;
@@ -194,29 +198,30 @@ static struct proc* proc_spawn_rd (char* name) {
 static void proc_register (struct proc* proc, struct cpu* cpu) {
   proc->cpu = cpu;
 
-  rw_spin_write_lock (&proc_tree_lock);
-  rw_spin_write_lock (&cpu->lock);
-
+  spin_lock (&cpu->lock);
   rbtree_insert (struct proc, &cpu->proc_run_q, &proc->cpu_run_q_link, cpu_run_q_link, pid);
-  rbtree_insert (struct proc, &proc_tree, &proc->proc_tree_link, proc_tree_link, pid);
 
   if (cpu->proc_current == NULL)
     cpu->proc_current = proc;
 
-  rw_spin_write_unlock (&cpu->lock);
+  spin_unlock (&cpu->lock);
+
+  rw_spin_write_lock (&proc_tree_lock);
+  rbtree_insert (struct proc, &proc_tree, &proc->proc_tree_link, proc_tree_link, pid);
   rw_spin_write_unlock (&proc_tree_lock);
 }
 
-static struct proc* proc_find_sched (void) {
+/* caller holds cpu->lock */
+static struct proc* proc_find_sched (struct cpu* cpu) {
   struct rb_node_link* node = NULL;
-  struct proc* start = thiscpu->proc_current;
+  struct proc* start = cpu->proc_current;
   struct proc* proc = NULL;
 
   if (start)
     node = &start->cpu_run_q_link;
 
   if (!node)
-    rbtree_first (&thiscpu->proc_run_q, node);
+    rbtree_first (&cpu->proc_run_q, node);
 
   if (!node)
     return NULL;
@@ -231,7 +236,7 @@ static struct proc* proc_find_sched (void) {
     rbtree_next (node, node);
 
     if (!node) {
-      rbtree_first (&thiscpu->proc_run_q, node);
+      rbtree_first (&cpu->proc_run_q, node);
     }
 
     if (node == first)
@@ -241,51 +246,81 @@ static struct proc* proc_find_sched (void) {
   return NULL;
 }
 
+static void proc_reap (void) {
+  struct proc* proc = NULL;
+  struct list_node_link* reap_list = NULL;
+
+  rw_spin_write_lock (&proc_tree_lock);
+
+  struct rb_node_link* node;
+  rbtree_first (&proc_tree, node);
+
+  while (node) {
+    struct rb_node_link* next;
+    rbtree_next (node, next);
+    proc = rbtree_entry (node, struct proc, proc_tree_link);
+
+    if (atomic_load (&proc->state) == PROC_DEAD) {
+      spin_lock (&proc->lock);
+      rbtree_delete (&proc_tree, &proc->proc_tree_link);
+      spin_unlock (&proc->lock);
+
+      list_append (reap_list, &proc->reap_link);
+    }
+
+    node = next;
+  }
+
+  rw_spin_write_unlock (&proc_tree_lock);
+
+  struct list_node_link *reap_link, *reap_link_tmp;
+  list_foreach (reap_list, reap_link, reap_link_tmp) {
+    proc = list_entry (reap_link, struct proc, reap_link);
+
+    list_remove (reap_list, &proc->reap_link);
+    DEBUG ("cleanup PID %d\n", proc->pid);
+    proc_cleanup (proc);
+  }
+}
+
 void proc_sched (void) {
+  if (atomic_fetch_add (&sched_cycles, 1) % SCHED_REAP_FREQ == 0)
+    proc_reap ();
+
   struct proc* next = NULL;
+  struct cpu* cpu = thiscpu;
 
-  rw_spin_read_lock (&thiscpu->lock);
+  spin_lock (&cpu->lock);
 
-  if (thiscpu->proc_run_q == NULL) {
-    rw_spin_read_unlock (&thiscpu->lock);
-    goto idle;
+  if (cpu->proc_run_q != NULL) {
+    next = proc_find_sched (cpu);
+    if (next)
+      cpu->proc_current = next;
   }
 
-  next = proc_find_sched ();
+  spin_unlock (&thiscpu->lock);
 
-  rw_spin_read_unlock (&thiscpu->lock);
-
-  if (next != NULL) {
-    rw_spin_write_lock (&thiscpu->lock);
-    thiscpu->proc_current = next;
-    rw_spin_write_unlock (&thiscpu->lock);
-  }
-
-  if (next != NULL && atomic_load (&next->state) == PROC_READY)
+  if ((next != NULL) && (atomic_load (&next->state) == PROC_READY))
     do_sched (next);
 
-idle:
   spin ();
 }
 
 void proc_kill (struct proc* proc) {
   atomic_store (&proc->state, PROC_DEAD);
 
-  rw_spin_write_lock (&proc_tree_lock);
-  spin_lock (&proc->lock);
-  rbtree_delete (&proc_tree, &proc->proc_tree_link);
-  spin_unlock (&proc->lock);
-  rw_spin_write_unlock (&proc_tree_lock);
-
   struct cpu* cpu = proc->cpu;
-  rw_spin_write_lock (&cpu->lock);
+
+  spin_lock (&cpu->lock);
+
   rbtree_delete (&cpu->proc_run_q, &proc->cpu_run_q_link);
-  rw_spin_write_unlock (&cpu->lock);
+  if (cpu->proc_current == proc)
+    cpu->proc_current = NULL;
+
+  spin_unlock (&cpu->lock);
 
   DEBUG ("killed PID %d\n", proc->pid);
 
-  proc_cleanup (proc);
-
   if (cpu == thiscpu)
     proc_sched ();
   else
@@ -293,22 +328,20 @@ void proc_kill (struct proc* proc) {
 }
 
 void proc_suspend (struct proc* proc, struct proc_suspension_q* sq) {
-  struct cpu* cpu;
-
   spin_lock (&proc->lock);
-
   atomic_store (&proc->state, PROC_SUSPENDED);
 
-  cpu = proc->cpu;
+  struct cpu* cpu = proc->cpu;
 
   /* remove from run q */
-  rw_spin_write_lock (&cpu->lock);
+  spin_lock (&cpu->lock);
   rbtree_delete (&cpu->proc_run_q, &proc->cpu_run_q_link);
   if (cpu->proc_current == proc)
     cpu->proc_current = NULL;
-  rw_spin_write_unlock (&cpu->lock);
+  spin_unlock (&cpu->lock);
 
   proc->suspension_q = sq;
+
   spin_lock (&proc->suspension_q->lock);
   rbtree_insert (struct proc, &proc->suspension_q->proc_tree, &proc->suspension_link,
                  suspension_link, pid);
@@ -319,25 +352,23 @@ void proc_suspend (struct proc* proc, struct proc_suspension_q* sq) {
   cpu_request_sched (cpu);
 }
 
-void proc_wakeup (struct proc* proc) {
-  struct cpu* cpu;
-
+void proc_resume (struct proc* proc) {
   spin_lock (&proc->lock);
 
-  cpu = proc->cpu;
+  struct cpu* cpu = proc->cpu;
+  struct proc_suspension_q* sq = proc->suspension_q;
 
-  spin_lock (&proc->suspension_q->lock);
-  rbtree_delete (&proc->suspension_q->proc_tree, &proc->suspension_link);
-  spin_unlock (&proc->suspension_q->lock);
+  spin_lock (&sq->lock);
+  rbtree_delete (&sq->proc_tree, &proc->suspension_link);
+  spin_unlock (&sq->lock);
 
   proc->suspension_q = NULL;
 
-  rw_spin_write_lock (&cpu->lock);
+  spin_lock (&cpu->lock);
   rbtree_insert (struct proc, &cpu->proc_run_q, &proc->cpu_run_q_link, cpu_run_q_link, pid);
-  rw_spin_write_unlock (&cpu->lock);
+  spin_unlock (&cpu->lock);
 
   atomic_store (&proc->state, PROC_READY);
-
   spin_unlock (&proc->lock);
 
   cpu_request_sched (cpu);

kernel/proc/proc.h

@@ -7,6 +7,7 @@
 #include <libk/rbtree.h>
 #include <libk/std.h>
 #include <proc/resource.h>
+#include <proc/suspension_q.h>
 #include <sync/spin_lock.h>
 #include <sys/mm.h>
 
@@ -39,6 +40,7 @@ struct proc {
   struct rb_node_link proc_tree_link;
   struct rb_node_link cpu_run_q_link;
   struct rb_node_link suspension_link;
+  struct list_node_link reap_link;
 
   struct list_node_link* mappings; /* pd.lock implicitly protects this field */
   struct proc_platformdata pdata;
@@ -51,12 +53,8 @@ struct proc {
   struct proc_suspension_q* suspension_q;
 };
 
-struct proc_suspension_q {
-  struct rb_node_link* proc_tree;
-  spin_lock_t lock;
-};
-
 void proc_suspend (struct proc* proc, struct proc_suspension_q* sq);
+void proc_resume (struct proc* proc);
 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,

kernel/proc/resource.c

@@ -4,7 +4,9 @@
 #include <libk/string.h>
 #include <mm/liballoc.h>
 #include <mm/pmm.h>
+#include <proc/mutex.h>
 #include <proc/proc.h>
+#include <proc/resource.h>
 #include <sync/spin_lock.h>
 #include <sys/debug.h>
 
@@ -33,7 +35,7 @@ void proc_drop_resource (struct proc* proc, struct proc_resource* resource) {
     rbtree_delete (&proc->resource_tree, &resource->proc_resource_tree_link);
     spin_unlock (&proc->lock);
 
-    resource->ops.cleanup (resource);
+    resource->ops.cleanup (proc, resource);
     free (resource);
   }
 }
@@ -53,10 +55,23 @@ static bool proc_create_resource_mem (struct proc_resource_mem* mem,
   return true;
 }
 
-static void proc_cleanup_resource_mem (struct proc_resource* resource) {
+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) {
   /* Check if resource RID already exists */
@@ -83,9 +98,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;
-    DEBUG ("resource=%p type=%d rid=%d paddr=%p, pages=%zu\n", resource, resource->type,
+    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;
+    DEBUG ("PR_MUTEX resource=%p, type=%d rid=%d\n", resource, resource->type, resource->rid);
+  } break;
   default: {
     free (resource);
     return NULL;

kernel/proc/resource.h

@@ -3,9 +3,11 @@
 
 #include <libk/rbtree.h>
 #include <libk/std.h>
+#include <proc/mutex.h>
 #include <sync/spin_lock.h>
 
-#define PR_MEM 0
+#define PR_MEM   0
+#define PR_MUTEX 1
 
 #define RV_PRIVATE 0
 #define RV_PUBLIC  1
@@ -30,9 +32,10 @@ struct proc_resource {
   struct rb_node_link proc_resource_tree_link;
   union {
     struct proc_resource_mem mem;
+    struct proc_mutex mutex;
   } u;
   struct {
-    void (*cleanup) (struct proc_resource* resource);
+    void (*cleanup) (struct proc* proc, struct proc_resource* resource);
   } ops;
 };
 

kernel/proc/src.mk

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

kernel/proc/suspension_q.h

@@ -0,0 +1,12 @@
+#ifndef _KERNEL_PROC_SUSPENTION_Q_H
+#define _KERNEL_PROC_SUSPENTION_Q_H
+
+#include <libk/rbtree.h>
+#include <sync/spin_lock.h>
+
+struct proc_suspension_q {
+  struct rb_node_link* proc_tree;
+  spin_lock_t lock;
+};
+
+#endif // _KERNEL_PROC_SUSPENTION_Q_H