vmbus_client: take over synic handling from the relay (#899)

Don't leak the synic details into `vmbus_relay` or
`vmbus_relay_intercept_device`. This will make it easier to use
`vmbus_client` without `vmbus_relay` in future changes.

Author: jstarks

Cargo.lock

@@ -8128,6 +8128,7 @@ version = "0.0.0"
 dependencies = [
  "anyhow",
  "futures",
+ "futures-concurrency",
  "getrandom",
  "guid",
  "inspect",
@@ -8136,10 +8137,12 @@ dependencies = [
  "pal_event",
  "test_with_tracing",
  "thiserror 2.0.0",
+ "tracelimit",
  "tracing",
  "vmbus_async",
  "vmbus_channel",
  "vmbus_core",
+ "vmcore",
  "zerocopy 0.8.14",
 ]
 
@@ -8202,10 +8205,8 @@ dependencies = [
  "inspect",
  "mesh",
  "mesh_protobuf",
- "once_cell",
  "pal_async",
  "pal_event",
- "parking_lot",
  "tracelimit",
  "tracing",
  "unicycle",
@@ -8227,17 +8228,16 @@ dependencies = [
  "inspect",
  "mesh",
  "pal_async",
+ "pal_event",
  "safeatomic",
  "task_control",
- "tracelimit",
  "tracing",
  "user_driver",
  "vmbus_channel",
  "vmbus_client",
  "vmbus_core",
  "vmbus_relay",
  "vmbus_ring",
- "vmbus_server",
  "vmcore",
  "zerocopy 0.8.14",
 ]

openhcl/underhill_core/src/worker.rs

@@ -2604,7 +2604,6 @@ async fn new_underhill_vm(
 
     let mut vmbus_server = None;
     let mut host_vmbus_relay = None;
-    let mut vmbus_synic_client = None;
 
     // VMBus
     if with_vmbus {
@@ -2671,8 +2670,6 @@ async fn new_underhill_vm(
             let builder = vmbus_client_hcl::vmbus_client_builder(relay_driver)
                 .context("failed to create synic client and message source")?;
 
-            let synic = builder.event_client().clone();
-
             let vmbus_relay = vmbus_relay::HostVmbusTransport::new(
                 relay_driver.clone(),
                 Arc::clone(vmbus.control()),
@@ -2682,7 +2679,6 @@ async fn new_underhill_vm(
             )
             .context("failed to create host vmbus transport")?;
 
-            vmbus_synic_client = Some(synic);
             host_vmbus_relay = Some(VmbusRelayHandle::new(
                 &tp,
                 state_units
@@ -2866,7 +2862,6 @@ async fn new_underhill_vm(
                     persistent_allocations: false,
                 })
                 .context("shutdown relay dma client")?,
-            vmbus_synic_client.clone().unwrap(),
             shutdown_guest,
         )?;
         vmbus_intercept_devices

support/inspect/src/lib.rs

@@ -1414,6 +1414,18 @@ impl<T: Into<ValueKind> + Clone> From<&'_ T> for ValueKind {
     }
 }
 
+impl Inspect for () {
+    fn inspect(&self, req: Request<'_>) {
+        req.respond();
+    }
+}
+
+impl InspectMut for () {
+    fn inspect_mut(&mut self, req: Request<'_>) {
+        req.respond();
+    }
+}
+
 macro_rules! inspect_value_immut {
     ($($(#[$attr:meta])* $ty:ty),* $(,)?) => {
         $(

support/mesh/mesh_channel/src/rpc.rs

@@ -12,6 +12,7 @@ use crate::RecvError;
 use mesh_node::message::MeshField;
 use mesh_protobuf::Protobuf;
 use std::convert::Infallible;
+use std::fmt::Debug;
 use std::future::Future;
 use std::pin::Pin;
 use std::task::ready;
@@ -21,13 +22,19 @@ use thiserror::Error;
 /// An RPC message for a request with input of type `I` and output of type `R`.
 /// The receiver of the message should process the request and return results
 /// via the `Sender<R>`.
-#[derive(Debug, Protobuf)]
+#[derive(Protobuf)]
 #[mesh(
     bound = "I: 'static + MeshField + Send, R: 'static + MeshField + Send",
     resource = "mesh_node::resource::Resource"
 )]
 pub struct Rpc<I, R>(I, OneshotSender<R>);
 
+impl<I: Debug, R> Debug for Rpc<I, R> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_tuple("Rpc").field(&self.0).finish()
+    }
+}
+
 /// An RPC message with a failable result.
 pub type FailableRpc<I, R> = Rpc<I, RemoteResult<R>>;
 
@@ -118,6 +125,14 @@ impl<I, R: 'static + Send> Rpc<I, Result<R, RemoteError>> {
         let r = f(self.0).await;
         self.1.send(r.map_err(RemoteError::new));
     }
+
+    /// Fails the RPC with the specified error.
+    pub fn fail<E>(self, error: E)
+    where
+        E: Into<Box<dyn std::error::Error + Send + Sync>>,
+    {
+        self.1.send(Err(RemoteError::new(error)));
+    }
 }
 
 /// A trait implemented by objects that can send RPC requests.

vm/devices/vmbus/vmbus_client/Cargo.toml

@@ -10,15 +10,18 @@ rust-version.workspace = true
 vmbus_async.workspace = true
 vmbus_channel.workspace = true
 vmbus_core.workspace = true
+vmcore.workspace = true
 
 guid.workspace = true
 mesh.workspace = true
 pal_async.workspace = true
 pal_event.workspace = true
 inspect.workspace = true
+tracelimit.workspace = true
 
 anyhow.workspace = true
 futures.workspace = true
+futures-concurrency.workspace = true
 thiserror.workspace = true
 tracing.workspace = true
 zerocopy.workspace = true