[Mammoth] Add Channel object for simple IPC messages

lib/mammoth/src/channel.cpp

@@ -0,0 +1,61 @@
+#include "mammoth/channel.h"
+
+#include <zcall.h>
+
+#include "mammoth/debug.h"
+
+namespace {
+
+uint64_t strlen(const char* ptr) {
+  uint64_t len = 0;
+  while (*ptr != '\0') {
+    len++;
+    ptr++;
+  }
+  return len;
+}
+
+}  // namespace
+
+void Channel::adopt_cap(uint64_t id) {
+  if (chan_cap_ != 0) {
+    crash("Adopting over channel.", Z_ERR_EXISTS);
+  }
+  chan_cap_ = id;
+}
+uint64_t Channel::release_cap() {
+  uint64_t cap = chan_cap_;
+  chan_cap_ = 0;
+  return cap;
+}
+
+z_err_t Channel::WriteStr(const char* msg) {
+  if (!chan_cap_) {
+    return Z_ERR_NULL;
+  }
+  uint64_t type = 11;
+  return ZChannelSend(chan_cap_, type, strlen(msg),
+                      reinterpret_cast<const uint8_t*>(msg), 0, 0);
+}
+
+z_err_t Channel::ReadStr(char* buffer, uint64_t* size) {
+  if (!chan_cap_) {
+    return Z_ERR_NULL;
+  }
+  uint64_t type;
+  uint64_t num_caps;
+  return ZChannelRecv(chan_cap_, *size, reinterpret_cast<uint8_t*>(buffer), 0,
+                      0, &type, size, &num_caps);
+}
+
+z_err_t CreateChannels(Channel& c1, Channel& c2) {
+  uint64_t chan1, chan2;
+  z_err_t err = ZChannelCreate(&chan1, &chan2);
+  if (err != Z_OK) {
+    return err;
+  }
+
+  c1.adopt_cap(chan1);
+  c2.adopt_cap(chan2);
+  return Z_OK;
+}

lib/mammoth/src/debug.cpp

@@ -29,3 +29,8 @@ void check(uint64_t code) {
   }
   ZProcessExit(code);
 }
+
+void crash(const char* str, uint64_t code) {
+  dbgln(str);
+  ZProcessExit(code);
+}

lib/mammoth/src/process.cpp

@@ -1,9 +1,10 @@
-#include "include/mammoth/process.h"
+#include "mammoth/process.h"
 
 #include <zcall.h>
 #include <zerrors.h>
 
-#include "include/mammoth/debug.h"
+#include "mammoth/channel.h"
+#include "mammoth/debug.h"
 
 namespace {
 
@@ -83,16 +84,15 @@ uint64_t LoadElfProgram(uint64_t base, uint64_t as_cap) {
 }  // namespace
 
 uint64_t SpawnProcessFromElfRegion(uint64_t program) {
-  dbgln("Channel Create");
-  uint64_t local_chan;
-  uint64_t foreign_chan;
-  check(ZChannelCreate(&local_chan, &foreign_chan));
+  Channel local, foreign;
+  check(CreateChannels(local, foreign));
 
   dbgln("Spawn");
   uint64_t proc_cap;
   uint64_t as_cap;
-  check(ZProcessSpawn(Z_INIT_PROC_SELF, foreign_chan, &proc_cap, &as_cap,
-                      &foreign_chan));
+  uint64_t foreign_chan_id;
+  check(ZProcessSpawn(Z_INIT_PROC_SELF, foreign.release_cap(), &proc_cap,
+                      &as_cap, &foreign_chan_id));
 
   uint64_t entry_point = LoadElfProgram(program, as_cap);
   dbgln("Thread Create");
@@ -100,10 +100,9 @@ uint64_t SpawnProcessFromElfRegion(uint64_t program) {
   check(ZThreadCreate(proc_cap, &thread_cap));
 
   dbgln("Thread start");
-  check(ZThreadStart(thread_cap, entry_point, foreign_chan, 0));
+  check(ZThreadStart(thread_cap, entry_point, foreign_chan_id, 0));
 
-  const uint8_t* msg = reinterpret_cast<const uint8_t*>("Hello!");
-  check(ZChannelSend(local_chan, 0, 7, msg, 0, 0));
+  local.WriteStr("Hello!");
 
   return Z_OK;
 }