[mammoth] Move EndpointClient to move-only semantics.

sys/denali/client/denali_client.cpp

@@ -11,7 +11,7 @@ glcr::ErrorOr<MappedMemoryRegion> DenaliClient::ReadSectors(
       .lba = lba,
       .size = num_sectors,
   };
-  auto pair_or = endpoint_.CallEndpoint<DenaliRead, DenaliReadResponse>(read);
+  auto pair_or = endpoint_->CallEndpoint<DenaliRead, DenaliReadResponse>(read);
   if (!pair_or) {
     return pair_or.error();
   }

sys/denali/denali.cpp

@@ -14,13 +14,15 @@ uint64_t main(uint64_t init_port_cap) {
   AhciDriver driver;
   RET_ERR(driver.Init());
 
-  EndpointClient yellowstone = EndpointClient::AdoptEndpoint(gInitEndpointCap);
+  glcr::UniquePtr<EndpointClient> yellowstone =
+      EndpointClient::AdoptEndpoint(gInitEndpointCap);
   YellowstoneGetReq req{
       .type = kYellowstoneGetRegistration,
   };
   auto resp_cap_or =
       yellowstone
-          .CallEndpoint<YellowstoneGetReq, YellowstoneGetRegistrationResp>(req);
+          ->CallEndpoint<YellowstoneGetReq, YellowstoneGetRegistrationResp>(
+              req);
   if (!resp_cap_or.ok()) {
     dbgln("Bad call");
     check(resp_cap_or.error());
@@ -30,8 +32,9 @@ uint64_t main(uint64_t init_port_cap) {
 
   ASSIGN_OR_RETURN(glcr::UniquePtr<EndpointServer> endpoint,
                    EndpointServer::Create());
-  ASSIGN_OR_RETURN(EndpointClient client, endpoint->CreateClient());
-  notify.WriteMessage("denali", client.GetCap());
+  ASSIGN_OR_RETURN(glcr::UniquePtr<EndpointClient> client,
+                   endpoint->CreateClient());
+  notify.WriteMessage("denali", client->GetCap());
 
   DenaliServer server(glcr::Move(endpoint), driver);
   RET_ERR(server.RunServer());

sys/denali/include/denali/denali_client.h

@@ -6,12 +6,13 @@
 
 class DenaliClient {
  public:
-  DenaliClient(const EndpointClient& endpoint) : endpoint_(endpoint) {}
+  DenaliClient(glcr::UniquePtr<EndpointClient> endpoint)
+      : endpoint_(glcr::Move(endpoint)) {}
 
   glcr::ErrorOr<MappedMemoryRegion> ReadSectors(uint64_t device_id,
                                                 uint64_t lba,
                                                 uint64_t num_sectors);
 
  private:
-  EndpointClient endpoint_;
+  glcr::UniquePtr<EndpointClient> endpoint_;
 };

sys/yellowstone/hw/gpt.cpp

@@ -47,11 +47,12 @@ struct PartitionEntry {
   char partition_name[72];
 } __attribute__((packed));
 
-GptReader::GptReader(const DenaliClient& client) : denali_(client) {}
+GptReader::GptReader(glcr::UniquePtr<DenaliClient> denali)
+    : denali_(glcr::Move(denali)) {}
 
 glcr::ErrorCode GptReader::ParsePartitionTables() {
   ASSIGN_OR_RETURN(MappedMemoryRegion lba_1_and_2,
-                   denali_.ReadSectors(0, 0, 2));
+                   denali_->ReadSectors(0, 0, 2));
   uint16_t* mbr_sig = reinterpret_cast<uint16_t*>(lba_1_and_2.vaddr() + 0x1FE);
   if (*mbr_sig != 0xAA55) {
     return glcr::FAILED_PRECONDITION;
@@ -86,7 +87,7 @@ glcr::ErrorCode GptReader::ParsePartitionTables() {
 
   ASSIGN_OR_RETURN(
       MappedMemoryRegion part_table,
-      denali_.ReadSectors(0, header->lba_partition_entries, num_blocks));
+      denali_->ReadSectors(0, header->lba_partition_entries, num_blocks));
   dbgln("Entries");
   for (uint64_t i = 0; i < num_partitions; i++) {
     PartitionEntry* entry = reinterpret_cast<PartitionEntry*>(

sys/yellowstone/hw/gpt.h

@@ -6,10 +6,10 @@
 
 class GptReader {
  public:
-  GptReader(const DenaliClient&);
+  GptReader(glcr::UniquePtr<DenaliClient> denali);
 
   glcr::ErrorCode ParsePartitionTables();
 
  private:
-  DenaliClient denali_;
+  glcr::UniquePtr<DenaliClient> denali_;
 };

sys/yellowstone/yellowstone.cpp

@@ -19,12 +19,13 @@ uint64_t main(uint64_t port_cap) {
 
   uint64_t vaddr;
   check(ZAddressSpaceMap(gSelfVmasCap, 0, gBootDenaliVmmoCap, &vaddr));
-  ASSIGN_OR_RETURN(EndpointClient client, server->GetServerClient());
-  check(SpawnProcessFromElfRegion(vaddr, client));
+  ASSIGN_OR_RETURN(glcr::UniquePtr<EndpointClient> client,
+                   server->GetServerClient());
+  check(SpawnProcessFromElfRegion(vaddr, glcr::Move(client)));
 
   check(ZAddressSpaceMap(gSelfVmasCap, 0, gBootVictoriaFallsVmmoCap, &vaddr));
   ASSIGN_OR_RETURN(client, server->GetServerClient());
-  check(SpawnProcessFromElfRegion(vaddr, client));
+  check(SpawnProcessFromElfRegion(vaddr, glcr::Move(client)));
 
   check(server_thread.Join());
   check(registration_thread.Join());

sys/yellowstone/yellowstone_server.cpp

@@ -21,9 +21,8 @@ void RegistrationThreadBootstrap(void* yellowstone) {
 }
 
 glcr::ErrorCode HandleDenaliRegistration(z_cap_t endpoint_cap) {
-  EndpointClient endpoint = EndpointClient::AdoptEndpoint(endpoint_cap);
-  DenaliClient client(endpoint);
-  GptReader reader(client);
+  GptReader reader(glcr::UniquePtr<DenaliClient>(
+      new DenaliClient(EndpointClient::AdoptEndpoint(endpoint_cap))));
 
   return reader.ParsePartitionTables();
 }
@@ -103,6 +102,7 @@ void YellowstoneServer::RegistrationThread() {
   }
 }
 
-glcr::ErrorOr<EndpointClient> YellowstoneServer::GetServerClient() {
+glcr::ErrorOr<glcr::UniquePtr<EndpointClient>>
+YellowstoneServer::GetServerClient() {
   return server_->CreateClient();
 }

sys/yellowstone/yellowstone_server.h

@@ -16,7 +16,7 @@ class YellowstoneServer {
   void ServerThread();
   void RegistrationThread();
 
-  glcr::ErrorOr<EndpointClient> GetServerClient();
+  glcr::ErrorOr<glcr::UniquePtr<EndpointClient>> GetServerClient();
 
  private:
   glcr::UniquePtr<EndpointServer> server_;