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);
+}