Message passing / mail system

kernel/proc/mail.c

@@ -0,0 +1,132 @@
+#include <libk/std.h>
+#include <libk/string.h>
+#include <mm/liballoc.h>
+#include <proc/mail.h>
+#include <proc/proc.h>
+#include <proc/resource.h>
+#include <proc/suspension_q.h>
+#include <sys/debug.h>
+#include <sys/smp.h>
+
+bool proc_cleanup_resource_mail (struct proc_resource* resource, struct cpu** reschedule_cpu) {
+  struct proc_mail* mail = &resource->u.mail;
+  bool reschedule = PROC_NO_RESCHEDULE;
+
+  spin_lock (&mail->resource->lock);
+
+  if (mail->pending_mesg != NULL)
+    free (mail->pending_mesg);
+
+  mail->pending_mesg_size = 0;
+
+  spin_lock (&mail->send_sq.lock);
+
+  while (mail->send_sq.proc_list != NULL) {
+    struct list_node_link* node = mail->send_sq.proc_list;
+    struct proc_sq_entry* sq_entry = list_entry (node, struct proc_sq_entry, sq_link);
+    struct proc* suspended_proc = sq_entry->proc;
+
+    spin_unlock (&mail->send_sq.lock);
+    spin_unlock (&mail->resource->lock);
+
+    reschedule = reschedule || proc_sq_resume (suspended_proc, sq_entry, reschedule_cpu);
+
+    spin_lock (&mail->resource->lock);
+    spin_lock (&mail->send_sq.lock);
+  }
+
+  spin_unlock (&mail->send_sq.lock);
+
+  spin_unlock (&mail->resource->lock);
+
+  return reschedule;
+}
+
+bool proc_mail_send (struct proc* proc, struct proc_mail* mail, struct cpu** reschedule_cpu,
+                     void* data, size_t data_size) {
+  spin_lock (&mail->resource->lock);
+  spin_lock (&mail->recv_sq.lock);
+
+  /* if receiver available, hand off directly */
+  struct list_node_link* node = mail->recv_sq.proc_list;
+
+  if (node != NULL) {
+    struct proc_sq_entry* sq_entry = list_entry (node, struct proc_sq_entry, sq_link);
+    struct proc* resumed_proc = sq_entry->proc;
+
+    spin_unlock (&mail->recv_sq.lock);
+    spin_unlock (&mail->resource->lock);
+
+    spin_lock (&proc->lock);
+
+    if (resumed_proc->mail_recv_buffer != NULL) {
+      size_t copy_size =
+          (data_size < resumed_proc->mail_recv_size) ? data_size : resumed_proc->mail_recv_size;
+      memcpy (resumed_proc->mail_recv_buffer, data, copy_size);
+
+      resumed_proc->mail_recv_buffer = NULL;
+      resumed_proc->mail_recv_size = 0;
+    }
+
+    spin_unlock (&proc->lock);
+
+    return proc_sq_resume (resumed_proc, sq_entry, reschedule_cpu);
+  }
+
+  spin_unlock (&mail->recv_sq.lock);
+
+  /* mail full */
+  if (mail->pending_mesg != NULL) {
+    return proc_sq_suspend (proc, &mail->send_sq, &mail->resource->lock, reschedule_cpu);
+  }
+
+  /* mail is empty and nobody is waiting */
+  mail->pending_mesg = malloc (data_size);
+  memcpy (mail->pending_mesg, data, data_size);
+  mail->pending_mesg_size = data_size;
+
+  spin_unlock (&mail->resource->lock);
+
+  return PROC_NO_RESCHEDULE;
+}
+
+bool proc_mail_receive (struct proc* proc, struct proc_mail* mail, struct cpu** reschedule_cpu,
+                        void* recv_buffer, size_t recv_size) {
+  spin_lock (&proc->lock);
+  proc->mail_recv_buffer = recv_buffer;
+  proc->mail_recv_size = recv_size;
+  spin_unlock (&proc->lock);
+
+  spin_lock (&mail->resource->lock);
+
+  /* consume mesg if available */
+  if (mail->pending_mesg != NULL) {
+    memcpy (recv_buffer, mail->pending_mesg, recv_size);
+    free (mail->pending_mesg);
+    mail->pending_mesg = NULL;
+    mail->pending_mesg_size = 0;
+
+    /* check for suspended sender */
+    spin_lock (&mail->send_sq.lock);
+
+    struct list_node_link* node = mail->send_sq.proc_list;
+
+    if (node != NULL) {
+      struct proc_sq_entry* sq_entry = list_entry (node, struct proc_sq_entry, sq_link);
+      struct proc* resumed_proc = sq_entry->proc;
+
+      spin_unlock (&mail->send_sq.lock);
+      spin_unlock (&mail->resource->lock);
+
+      return proc_sq_resume (resumed_proc, sq_entry, reschedule_cpu);
+    }
+
+    spin_unlock (&mail->send_sq.lock);
+    spin_unlock (&mail->resource->lock);
+
+    return PROC_NO_RESCHEDULE;
+  }
+
+  /* nothing to receive */
+  return proc_sq_suspend (proc, &mail->recv_sq, &mail->resource->lock, reschedule_cpu);
+}

kernel/proc/mail.h

@@ -0,0 +1,26 @@
+#ifndef _KERNEL_PROC_MAIL_H
+#define _KERNEL_PROC_MAIL_H
+
+#include <libk/std.h>
+#include <proc/suspension_q.h>
+
+struct proc;
+struct proc_resource;
+struct cpu;
+
+struct proc_mail {
+  struct proc_resource* resource;
+
+  struct proc_suspension_q send_sq;
+  struct proc_suspension_q recv_sq;
+  void* pending_mesg;
+  size_t pending_mesg_size;
+};
+
+bool proc_cleanup_resource_mail (struct proc_resource* resource, struct cpu** reschedule_cpu);
+bool proc_mail_send (struct proc* proc, struct proc_mail* mail, struct cpu** reschedule_cpu,
+                     void* data, size_t data_size);
+bool proc_mail_receive (struct proc* proc, struct proc_mail* mail, struct cpu** reschedule_cpu,
+                        void* recv_buffer, size_t recv_size);
+
+#endif // _KERNEL_PROC_MAIL_H

kernel/proc/proc.h

@@ -32,6 +32,7 @@ struct cpu;
 
 struct proc {
   int pid;
+  int exec_pid;
   struct rb_node_link proc_tree_link;
   struct rb_node_link procgroup_memb_tree_link;
   struct list_node_link cpu_run_q_link;
@@ -44,6 +45,8 @@ struct proc {
   struct cpu* cpu;
   atomic_int state;
   uintptr_t uvaddr_argument;
+  void* mail_recv_buffer;
+  size_t mail_recv_size;
 };
 
 void proc_sched (void);

kernel/proc/procgroup.c

@@ -14,6 +14,16 @@ static struct rb_node_link* procgroup_tree = NULL;
 static spin_lock_t procgroup_tree_lock = SPIN_LOCK_INIT;
 static atomic_int pgids = 0;
 
+struct procgroup* procgroup_find (int pgid) {
+  struct procgroup* procgroup = NULL;
+
+  spin_lock (&procgroup_tree_lock);
+  rbtree_find (struct procgroup, &procgroup_tree, pgid, procgroup, procgroup_tree_link, pgid);
+  spin_unlock (&procgroup_tree_lock);
+
+  return procgroup;
+}
+
 uintptr_t procgroup_map (struct procgroup* procgroup, uintptr_t vaddr, size_t pages, uint32_t flags,
                          uintptr_t* out_paddr) {
   spin_lock (&procgroup->lock);
@@ -141,6 +151,11 @@ struct procgroup* procgroup_create (void) {
   procgroup->pd.cr3_paddr = mm_alloc_user_pd_phys ();
   procgroup->map_base = PROC_MAP_BASE;
 
+  if (proc_create_resource_mail (procgroup, 1) == NULL) {
+    free (procgroup);
+    return NULL;
+  }
+
   spin_lock (&procgroup_tree_lock);
   rbtree_insert (struct procgroup, &procgroup_tree, &procgroup->procgroup_tree_link,
                  procgroup_tree_link, pgid);

kernel/proc/procgroup.h

@@ -40,5 +40,6 @@ void procgroup_detach (struct procgroup* procgroup, struct proc* proc);
 uintptr_t procgroup_map (struct procgroup* procgroup, uintptr_t vaddr, size_t pages, uint32_t flags,
                          uintptr_t* out_paddr);
 bool procgroup_unmap (struct procgroup* procgroup, uintptr_t start_vaddr, size_t pages);
+struct procgroup* procgroup_find (int pgid);
 
 #endif // _KERNEL_PROC_PROCGROUP_H

kernel/proc/resource.c

@@ -5,6 +5,7 @@
 #include <libk/string.h>
 #include <mm/liballoc.h>
 #include <mm/pmm.h>
+#include <proc/mail.h>
 #include <proc/mutex.h>
 #include <proc/proc.h>
 #include <proc/procgroup.h>
@@ -49,6 +50,32 @@ struct proc_resource* proc_create_resource_mutex (struct procgroup* procgroup, i
   return resource;
 }
 
+struct proc_resource* proc_create_resource_mail (struct procgroup* procgroup, int rid) {
+  struct proc_resource* resource;
+
+  resource = proc_find_resource (procgroup, rid);
+  if (resource != NULL)
+    return resource;
+
+  resource = malloc (sizeof (*resource));
+  if (resource == NULL)
+    return NULL;
+
+  memset (resource, 0, sizeof (*resource));
+  resource->lock = SPIN_LOCK_INIT;
+  resource->ops.cleanup = &proc_cleanup_resource_mail;
+  resource->u.mail.resource = resource;
+  resource->rid = rid;
+  resource->type = PR_MAIL;
+
+  spin_lock (&procgroup->lock);
+  rbtree_insert (struct proc_resource, &procgroup->resource_tree, &resource->resource_tree_link,
+                 resource_tree_link, rid);
+  spin_unlock (&procgroup->lock);
+
+  return resource;
+}
+
 bool proc_delete_resource (struct proc_resource* resource, struct cpu** reschedule_cpu) {
   bool reschedule = resource->ops.cleanup (resource, reschedule_cpu);
   free (resource);

kernel/proc/resource.h

@@ -4,10 +4,12 @@
 #include <libk/list.h>
 #include <libk/rbtree.h>
 #include <libk/std.h>
+#include <proc/mail.h>
 #include <proc/mutex.h>
 #include <sync/spin_lock.h>
 
-#define PR_MUTEX 1
+#define PR_MUTEX 0
+#define PR_MAIL  1
 
 struct proc;
 struct procgroup;
@@ -20,6 +22,7 @@ struct proc_resource {
   struct rb_node_link resource_tree_link;
   union {
     struct proc_mutex mutex;
+    struct proc_mail mail;
   } u;
   struct {
     bool (*cleanup) (struct proc_resource* resource, struct cpu** reschedule_cpu);
@@ -28,6 +31,7 @@ struct proc_resource {
 
 struct proc_resource* proc_find_resource (struct procgroup* procgroup, int rid);
 struct proc_resource* proc_create_resource_mutex (struct procgroup* procgroup, int rid);
+struct proc_resource* proc_create_resource_mail (struct procgroup* procgroup, int rid);
 bool proc_delete_resource (struct proc_resource* resource, struct cpu** reschedule_cpu);
 
 #endif // _KERNEL_PROC_RESOURCE_H

kernel/proc/src.mk

@@ -2,10 +2,12 @@ c += proc/proc.c \
 		 proc/resource.c \
 		 proc/mutex.c \
 		 proc/procgroup.c \
-		 proc/suspension_q.c
+		 proc/suspension_q.c \
+		 proc/mail.c
 
 o += proc/proc.o \
 		 proc/resource.o \
 		 proc/mutex.o \
 		 proc/procgroup.o \
-		 proc/suspension_q.o
+		 proc/suspension_q.o \
+		 proc/mail.o