[gpt] Provide hardware.block.volume.VolumeManager

Implements a subset of the VolumeManager interface for the GPT driver,
allowing runtime allocation of GPT partitions.

The GPT device tree now contains a `gpt` node which offers the
VolumeManager protocol.  Note that partitions are *not* moved to
children beneath the `gpt` node, since doing so would require extensive
refactoring of the system (i.e. removing hard-coded GPT paths).  The
`gpt` device is a peer of the partition devices.

Newly allocated partitions are immediately bound, and other partitions
are unaffected (which is unlike the `gpt` host tool which rebinds all
GPT drivers upon any header modifications).

This is intended to support the storage-benchmark tests on systems which
do not have an FVM.

This change required refactoring the GptDevice library to receive a
BlockDevice rather than a BlockProxy, since we can't create a BlockProxy
for driver->driver communication.  The GPT driver provides an
implementation of the BlockDevice interface which directly communicates
using the inter-driver Banjo block protocol.

Bug: 126938
Change-Id: Ibe6717cf458dfad7fcc35f10fe8dc33adde3b103
Tested: Manually paved a NUC to ensure paving works with this change.
Reviewed-on: https://fuchsia-review.googlesource.com/c/fuchsia/+/868940
Size-Review: James Sullivan <[email protected]>
Reviewed-by: Chris Suter <[email protected]>
Commit-Queue: James Sullivan <[email protected]>
Reviewed-by: Suraj Malhotra <[email protected]>

Author: James Sullivan

src/devices/block/bin/gpt/gpt.cc

@@ -22,6 +22,8 @@
 #include <gpt/gpt.h>
 #include <gpt/guid.h>
 
+#include "src/lib/storage/block_client/cpp/remote_block_device.h"
+
 using gpt::GptDevice;
 using gpt::GuidProperties;
 using gpt::KnownGuid;
@@ -114,7 +116,7 @@ char* FlagsToCString(char* dst, size_t dst_len, const uint8_t* guid, uint64_t fl
 }
 
 std::unique_ptr<GptDevice> Init(const char* dev) {
-  zx::result block = component::Connect<fuchsia_hardware_block::Block>(dev);
+  zx::result block = component::Connect<fuchsia_hardware_block_volume::Volume>(dev);
   if (block.is_error()) {
     fprintf(stderr, "gpt: error opening %s: %s\n", dev, block.status_string());
     return nullptr;
@@ -144,9 +146,14 @@ std::unique_ptr<GptDevice> Init(const char* dev) {
     return nullptr;
   }
 
+  auto device = block_client::RemoteBlockDevice::Create(std::move(block.value()));
+  if (device.is_error()) {
+    fprintf(stderr, "Failed to create block client: %s\n", device.status_string());
+    return nullptr;
+  }
   std::unique_ptr<GptDevice> gpt;
   if (zx_status_t status =
-          GptDevice::Create(std::move(block.value()), std::move(controller.value()),
+          GptDevice::Create(std::move(device.value()), std::move(controller.value()),
                             info.block_size, info.block_count, &gpt);
       status != ZX_OK) {
     fprintf(stderr, "gpt: error initializing GPT from %s: %s\n", dev, zx_status_get_string(status));
@@ -262,10 +269,8 @@ zx_status_t Commit(GptDevice* gpt, const char* dev) {
     return status;
   }
 
-  // TODO(https://fxbug.dev/112484): this relies on multiplexing.
-  const fidl::WireResult result = fidl::WireCall(fidl::UnownedClientEnd<fuchsia_device::Controller>(
-                                                     gpt->device().channel().borrow()))
-                                      ->Rebind({});
+  fidl::UnownedClientEnd<fuchsia_device::Controller> controller = gpt->device().Controller();
+  const fidl::WireResult result = fidl::WireCall(controller)->Rebind({});
   if (!result.ok()) {
     fprintf(stderr, "gpt: gpt updated but device %s could not be rebound: %s. Please reboot.\n",
             dev, result.FormatDescription().c_str());
@@ -313,7 +318,7 @@ zx_status_t AddPartition(const char* dev, uint64_t start, uint64_t end, const ch
 
   uint8_t type[GPT_GUID_LEN];
   memset(type, 0xff, GPT_GUID_LEN);
-  zx_status_t rc = gpt->AddPartition(name, type, guid, start, end - start + 1, 0);
+  zx_status_t rc = gpt->AddPartition(name, type, guid, start, end - start + 1, 0).status_value();
   if (rc != ZX_OK) {
     fprintf(stderr, "Add partition failed: %s\n", zx_status_get_string(rc));
     return rc;
@@ -719,7 +724,7 @@ zx_status_t Repartition(int argc, char** argv, std::optional<PartitionScheme> sc
 
       printf("%s: %" PRIu64 " bytes, %" PRIu64 " blocks, %" PRIu64 "-%" PRIu64 "\n", name,
              byte_size, nblocks, start, end);
-      ZX_ASSERT(gpt->AddPartition(name, type, guid, start, end - start, 0) == ZX_OK);
+      ZX_ASSERT(gpt->AddPartition(name, type, guid, start, end - start, 0).status_value() == ZX_OK);
 
       start = end + 1;
     }

src/devices/block/drivers/gpt/BUILD.gn

@@ -32,7 +32,9 @@ fuchsia_driver("gpt-driver") {
   deps = [
     ":gpt_bind",
     "//sdk/banjo/fuchsia.hardware.block.partition:fuchsia.hardware.block.partition_banjo_cpp",
+    "//sdk/banjo/fuchsia.hardware.block.volume:fuchsia.hardware.block.volume_banjo_cpp",
     "//sdk/fidl/fuchsia.hardware.block.driver:fuchsia.hardware.block.driver_banjo_cpp",
+    "//sdk/fidl/fuchsia.hardware.block.volume:fuchsia.hardware.block.volume_cpp_wire",
     "//sdk/fidl/fuchsia.hardware.gpt.metadata:fuchsia.hardware.gpt.metadata_cpp_wire",
     "//sdk/lib/fit",
     "//sdk/lib/syslog/cpp:backend",
@@ -41,10 +43,13 @@ fuchsia_driver("gpt-driver") {
     "//src/devices/block/lib/common",
     "//src/devices/lib/driver",
     "//src/lib/ddk",
+    "//src/lib/fidl/cpp",
+    "//src/lib/storage/block_client/cpp",
     "//src/storage/gpt",
     "//zircon/system/ulib/fbl",
     "//zircon/system/ulib/sync",
     "//zircon/third_party/ulib/cksum",
+    "//zircon/third_party/ulib/safemath",
   ]
 }
 
@@ -74,12 +79,14 @@ test("gpt-device-test-bin") {
     "//src/lib/ddk",
     "//src/lib/ddktl",
     "//src/storage/gpt",
+    "//zircon/system/ulib/async-loop:async-loop-cpp",
     "//zircon/system/ulib/fbl",
     "//zircon/system/ulib/sync",
     "//zircon/system/ulib/zircon-internal",
     "//zircon/system/ulib/zx",
     "//zircon/system/ulib/zxtest",
     "//zircon/third_party/ulib/cksum",
+    "//zircon/third_party/ulib/safemath",
   ]
 }