vmbus_server: support VTL2 channels for vmbusproxy. (#916)

This change makes it possible for vmbusproxy to offer channels to VTL2.
Previously, vmbusproxy ignored an offer's target VTL and would always
offer to VTL0.

Author: SvenGroot

openvmm/hvlite_core/src/worker/dispatch.rs

@@ -1678,10 +1678,15 @@ impl InitializedVm {
             #[cfg(windows)]
             if let Some(proxy_handle) = vmbus_cfg.vmbusproxy_handle {
                 vmbus_proxy = Some(
-                    vmbus
-                        .start_kernel_proxy(&vmbus_driver, proxy_handle)
-                        .await
-                        .context("failed to start the vmbus proxy")?,
+                    vmbus_server::ProxyIntegration::start(
+                        &vmbus_driver,
+                        proxy_handle,
+                        vmbus.control(),
+                        vtl2_vmbus.as_ref().map(|server| server.control().clone()),
+                        Some(&gm),
+                    )
+                    .await
+                    .context("failed to start the vmbus proxy")?,
                 )
             }
 

vm/devices/vmbus/vmbus_server/src/lib.rs

@@ -569,15 +569,6 @@ impl VmbusServer {
         let _ = self.task.await;
     }
 
-    #[cfg(windows)]
-    pub async fn start_kernel_proxy(
-        &self,
-        driver: &(impl pal_async::driver::SpawnDriver + Clone),
-        handle: ProxyHandle,
-    ) -> std::io::Result<ProxyIntegration> {
-        ProxyIntegration::start(driver, handle, self.control(), Some(&self.control.mem)).await
-    }
-
     /// Returns an object that can be used to offer channels.
     pub fn control(&self) -> Arc<VmbusServerControl> {
         self.control.clone()

vm/devices/vmbus/vmbus_server/src/proxyintegration.rs

@@ -67,6 +67,7 @@ impl ProxyIntegration {
         driver: &(impl SpawnDriver + Clone),
         handle: ProxyHandle,
         server: Arc<VmbusServerControl>,
+        vtl2_server: Option<Arc<VmbusServerControl>>,
         mem: Option<&GuestMemory>,
     ) -> io::Result<Self> {
         let mut proxy = VmbusProxy::new(driver, handle)?;
@@ -79,7 +80,7 @@ impl ProxyIntegration {
         driver
             .spawn(
                 "vmbus_proxy",
-                proxy_thread(driver.clone(), proxy, server, cancel_ctx),
+                proxy_thread(driver.clone(), proxy, server, vtl2_server, cancel_ctx),
             )
             .detach();
 
@@ -98,15 +99,21 @@ struct ProxyTask {
     gpadls: Arc<Mutex<HashMap<u64, HashSet<GpadlId>>>>,
     proxy: Arc<VmbusProxy>,
     server: Arc<VmbusServerControl>,
+    vtl2_server: Option<Arc<VmbusServerControl>>,
 }
 
 impl ProxyTask {
-    fn new(control: Arc<VmbusServerControl>, proxy: Arc<VmbusProxy>) -> Self {
+    fn new(
+        server: Arc<VmbusServerControl>,
+        vtl2_server: Option<Arc<VmbusServerControl>>,
+        proxy: Arc<VmbusProxy>,
+    ) -> Self {
         Self {
             channels: Arc::new(Mutex::new(HashMap::new())),
             gpadls: Arc::new(Mutex::new(HashMap::new())),
             proxy,
-            server: control,
+            server,
+            vtl2_server,
         }
     }
 
@@ -213,12 +220,31 @@ impl ProxyTask {
         offer: vmbus_proxy::vmbusioctl::VMBUS_CHANNEL_OFFER,
         incoming_event: Event,
     ) -> Option<mesh::Receiver<ChannelRequest>> {
+        let server = match offer.TargetVtl {
+            0 => self.server.as_ref(),
+            2 => {
+                if let Some(server) = self.vtl2_server.as_ref() {
+                    server
+                } else {
+                    tracing::error!(?offer, "VTL2 offer without VTL2 server");
+                    return None;
+                }
+            }
+            _ => {
+                tracing::error!(?offer, "unsupported offer VTL");
+                return None;
+            }
+        };
+
         let channel_type = if offer.ChannelFlags & VMBUS_CHANNEL_ENUMERATE_DEVICE_INTERFACE != 0 {
             let pipe_mode = u32::from_ne_bytes(offer.UserDefined[..4].try_into().unwrap());
             let message_mode = match pipe_mode {
                 vmbus_proxy::vmbusioctl::VMBUS_PIPE_TYPE_BYTE => false,
                 vmbus_proxy::vmbusioctl::VMBUS_PIPE_TYPE_MESSAGE => true,
-                _ => panic!("BUGBUG: unsupported"),
+                _ => {
+                    tracing::error!(?offer, "unsupported offer pipe mode");
+                    return None;
+                }
             };
             ChannelType::Pipe { message_mode }
         } else {
@@ -244,7 +270,8 @@ impl ProxyTask {
         };
         let (request_send, request_recv) = mesh::channel();
         let (server_request_send, server_request_recv) = mesh::channel();
-        let recv = self.server.send.call_failable(
+
+        let recv = server.send.call_failable(
             OfferRequest::Offer,
             OfferInfo {
                 params: offer.into(),
@@ -429,11 +456,12 @@ async fn proxy_thread(
     spawner: impl Spawn,
     proxy: VmbusProxy,
     server: Arc<VmbusServerControl>,
+    vtl2_server: Option<Arc<VmbusServerControl>>,
     mut cancel: CancelContext,
 ) {
     let (send, recv) = mesh::channel();
     let proxy = Arc::new(proxy);
-    let task = Arc::new(ProxyTask::new(server, Arc::clone(&proxy)));
+    let task = Arc::new(ProxyTask::new(server, vtl2_server, Arc::clone(&proxy)));
     let offers = task.run_offers(send);
     let requests = task.run_channel_requests(spawner, recv);
     let cancellation = async {