[Yellowstone] Use mutex to wait for denali to spawn VFS.

Kind of a hacky way to pass a signal between threads but works as
a POC for thread synchronization.

lib/mammoth/CMakeLists.txt

@@ -5,6 +5,7 @@ add_library(mammoth STATIC
   src/endpoint_server.cpp
   src/init.cpp
   src/memory_region.cpp
+  src/mutex.cpp
   src/new.cpp
   src/process.cpp
   src/port_client.cpp

lib/mammoth/include/mammoth/mutex.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <glacier/status/error_or.h>
+#include <ztypes.h>
+
+class Mutex {
+ public:
+  Mutex(const Mutex&) = delete;
+  Mutex(Mutex&&);
+  Mutex& operator=(Mutex&&);
+
+  static glcr::ErrorOr<Mutex> Create();
+
+  glcr::ErrorCode Lock();
+  glcr::ErrorCode Release();
+
+ private:
+  z_cap_t mutex_cap_;
+
+  Mutex(z_cap_t mutex_cap) : mutex_cap_(mutex_cap) {}
+};

lib/mammoth/src/mutex.cpp

@@ -0,0 +1,23 @@
+#include "mammoth/mutex.h"
+
+#include <zcall.h>
+
+Mutex::Mutex(Mutex&& other) : mutex_cap_(other.mutex_cap_) {
+  other.mutex_cap_ = 0;
+}
+
+Mutex& Mutex::operator=(Mutex&& other) {
+  // TODO: Release existing mutex if it exists.
+  mutex_cap_ = other.mutex_cap_;
+  other.mutex_cap_ = 0;
+  return *this;
+}
+
+glcr::ErrorOr<Mutex> Mutex::Create() {
+  z_cap_t mutex_cap;
+  RET_ERR(ZMutexCreate(&mutex_cap));
+  return Mutex(mutex_cap);
+}
+
+glcr::ErrorCode Mutex::Lock() { return ZMutexLock(mutex_cap_); }
+glcr::ErrorCode Mutex::Release() { return ZMutexRelease(mutex_cap_); }

sys/yellowstone/yellowstone.cpp

@@ -8,6 +8,12 @@
 #include "hw/pcie.h"
 #include "yellowstone_server.h"
 
+glcr::ErrorCode SpawnProcess(z_cap_t vmmo_cap, z_cap_t yellowstone_cap) {
+  uint64_t vaddr;
+  RET_ERR(ZAddressSpaceMap(gSelfVmasCap, 0, vmmo_cap, &vaddr));
+  return SpawnProcessFromElfRegion(vaddr, yellowstone_cap);
+}
+
 uint64_t main(uint64_t port_cap) {
   dbgln("Yellowstone Initializing.");
   check(ParseInitPort(port_cap));
@@ -15,10 +21,13 @@ uint64_t main(uint64_t port_cap) {
   ASSIGN_OR_RETURN(auto server, YellowstoneServer::Create());
   Thread server_thread = server->RunServer();
 
-  uint64_t vaddr;
-  check(ZAddressSpaceMap(gSelfVmasCap, 0, gBootDenaliVmmoCap, &vaddr));
-  ASSIGN_OR_RETURN(YellowstoneClient client, server->CreateClient());
-  check(SpawnProcessFromElfRegion(vaddr, client.Capability()));
+  ASSIGN_OR_RETURN(YellowstoneClient client1, server->CreateClient());
+  check(SpawnProcess(gBootDenaliVmmoCap, client1.Capability()));
+
+  check(server->WaitDenaliRegistered());
+
+  ASSIGN_OR_RETURN(YellowstoneClient client2, server->CreateClient());
+  check(SpawnProcess(gBootVictoriaFallsVmmoCap, client2.Capability()));
 
   check(server_thread.Join());
   dbgln("Yellowstone Finished Successfully.");

sys/yellowstone/yellowstone_server.cpp

@@ -30,13 +30,19 @@ glcr::ErrorOr<PartitionInfo> HandleDenaliRegistration(z_cap_t endpoint_cap) {
 }  // namespace
 
 glcr::ErrorOr<glcr::UniquePtr<YellowstoneServer>> YellowstoneServer::Create() {
-  z_cap_t cap;
-  RET_ERR(ZEndpointCreate(&cap));
-  return glcr::UniquePtr<YellowstoneServer>(new YellowstoneServer(cap));
+  z_cap_t endpoint_cap;
+  RET_ERR(ZEndpointCreate(&endpoint_cap));
+
+  ASSIGN_OR_RETURN(Mutex mut, Mutex::Create());
+  RET_ERR(mut.Lock());
+
+  return glcr::UniquePtr<YellowstoneServer>(
+      new YellowstoneServer(endpoint_cap, glcr::Move(mut)));
 }
 
-YellowstoneServer::YellowstoneServer(z_cap_t endpoint_cap)
-    : YellowstoneServerBase(endpoint_cap) {}
+YellowstoneServer::YellowstoneServer(z_cap_t endpoint_cap, Mutex&& mutex)
+    : YellowstoneServerBase(endpoint_cap),
+      has_denali_mutex_(glcr::Move(mutex)) {}
 
 glcr::ErrorCode YellowstoneServer::HandleGetAhciInfo(const Empty&,
                                                      AhciInfo& info) {
@@ -69,13 +75,7 @@ glcr::ErrorCode YellowstoneServer::HandleRegisterEndpoint(
     device_id_ = part_info_or.value().device_id;
     lba_offset_ = part_info_or.value().partition_lba;
 
-    uint64_t vaddr;
-    check(ZAddressSpaceMap(gSelfVmasCap, 0, gBootVictoriaFallsVmmoCap, &vaddr));
-    auto client_or = CreateClient();
-    if (!client_or.ok()) {
-      check(client_or.error());
-    }
-    check(SpawnProcessFromElfRegion(vaddr, client_or.value().Capability()));
+    check(has_denali_mutex_.Release());
   } else if (req.endpoint_name() == "victoriafalls") {
     victoria_falls_cap_ = req.endpoint_capability();
   } else {
@@ -83,3 +83,8 @@ glcr::ErrorCode YellowstoneServer::HandleRegisterEndpoint(
   }
   return glcr::OK;
 }
+
+glcr::ErrorCode YellowstoneServer::WaitDenaliRegistered() {
+  RET_ERR(has_denali_mutex_.Lock());
+  return has_denali_mutex_.Release();
+}

sys/yellowstone/yellowstone_server.h

@@ -3,6 +3,7 @@
 #include <glacier/memory/unique_ptr.h>
 #include <glacier/status/error_or.h>
 #include <mammoth/endpoint_server.h>
+#include <mammoth/mutex.h>
 #include <mammoth/port_server.h>
 #include <mammoth/thread.h>
 
@@ -18,6 +19,8 @@ class YellowstoneServer : public YellowstoneServerBase {
   glcr::ErrorCode HandleRegisterEndpoint(const RegisterEndpointRequest&,
                                          Empty&) override;
 
+  glcr::ErrorCode WaitDenaliRegistered();
+
  private:
   // TODO: Store these in a data structure.
   z_cap_t denali_cap_ = 0;
@@ -27,5 +30,7 @@ class YellowstoneServer : public YellowstoneServerBase {
 
   PciReader pci_reader_;
 
-  YellowstoneServer(z_cap_t endpoint_cap);
+  Mutex has_denali_mutex_;
+
+  YellowstoneServer(z_cap_t endpoint_cap, Mutex&& mutex);
 };