vmbus_server: allow unstick to work without full memory mapping (#1857)

This change updates how the "unstick" functionality accesses channel
ring buffers by only mapping the control page, and using
`lockable_subrange` so that a `GuestMemory` implementation that doesn't
have a full mapping has the opportunity to create a partial mapping.

This allows unsticking a channel to work with alternative `GuestMemory`
implementations used in Hyper-V.

Author: SvenGroot

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

@@ -72,6 +72,7 @@ mod pipe_protocol {
 mod protocol {
     use crate::CONTROL_WORD_COUNT;
     use inspect::Inspect;
+    use safeatomic::AtomicSliceOps;
     use std::fmt::Debug;
     use std::sync::atomic::AtomicU32;
     use std::sync::atomic::Ordering;
@@ -97,7 +98,14 @@ mod protocol {
     /// A control page accessor.
     pub struct Control<'a>(pub &'a [AtomicU32; CONTROL_WORD_COUNT]);
 
-    impl Control<'_> {
+    impl<'a> Control<'a> {
+        pub fn from_page(page: &'a guestmem::Page) -> Option<Self> {
+            let slice = page.as_atomic_slice()?[..CONTROL_WORD_COUNT]
+                .try_into()
+                .unwrap();
+            Some(Self(slice))
+        }
+
         pub fn inp(&self) -> &AtomicU32 {
             &self.0[0]
         }
@@ -1208,31 +1216,27 @@ impl<M: RingMem> Inspect for InnerRing<M> {
 ///
 /// Panics if control_page is not aligned.
 pub fn inspect_ring(control_page: &guestmem::Page, response: &mut inspect::Response<'_>) {
-    let control = control_page.as_atomic_slice().unwrap()[..CONTROL_WORD_COUNT]
-        .try_into()
-        .unwrap();
-
-    response.field("control", Control(control));
+    let control = Control::from_page(control_page).expect("control page is not aligned");
+    response.field("control", control);
 }
 
 /// Returns whether a ring buffer is in a state where the receiving end might
 /// need a signal.
-pub fn reader_needs_signal<M: RingMem>(mem: M) -> bool {
-    InnerRing::new(mem).is_ok_and(|ring| {
-        let control = ring.control();
+pub fn reader_needs_signal(control_page: &guestmem::Page) -> bool {
+    Control::from_page(control_page).is_some_and(|control| {
         control.interrupt_mask().load(Ordering::Relaxed) == 0
             && (control.inp().load(Ordering::Relaxed) != control.outp().load(Ordering::Relaxed))
     })
 }
 
 /// Returns whether a ring buffer is in a state where the sending end might need
 /// a signal.
-pub fn writer_needs_signal<M: RingMem>(mem: M) -> bool {
-    InnerRing::new(mem).is_ok_and(|ring| {
-        let control = ring.control();
+pub fn writer_needs_signal(control_page: &guestmem::Page, ring_size: u32) -> bool {
+    Control::from_page(control_page).is_some_and(|control| {
         let pending_size = control.pending_send_size().load(Ordering::Relaxed);
         pending_size != 0
-            && ring.free(
+            && ring_free(
+                ring_size,
                 control.inp().load(Ordering::Relaxed),
                 control.outp().load(Ordering::Relaxed),
             ) >= pending_size
@@ -1298,16 +1302,20 @@ impl<M: RingMem> InnerRing<M> {
     }
 
     fn free(&self, inp: u32, outp: u32) -> u32 {
-        // It's not possible to fully fill the ring since that state would be
-        // indistinguishable from the empty ring. So subtract 8 bytes from the
-        // result.
-        if outp > inp {
-            // |....inp____outp.....|
-            outp - inp - 8
-        } else {
-            // |____outp....inp_____|
-            self.size - (inp - outp) - 8
-        }
+        ring_free(self.size, inp, outp)
+    }
+}
+
+fn ring_free(size: u32, inp: u32, outp: u32) -> u32 {
+    // It's not possible to fully fill the ring since that state would be
+    // indistinguishable from the empty ring. So subtract 8 bytes from the
+    // result.
+    if outp > inp {
+        // |....inp____outp.....|
+        outp - inp - 8
+    } else {
+        // |____outp....inp_____|
+        size - (inp - outp) - 8
     }
 }
 

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

@@ -77,7 +77,6 @@ use vmbus_channel::bus::ParentBus;
 use vmbus_channel::bus::RestoreResult;
 use vmbus_channel::gpadl::GpadlMap;
 use vmbus_channel::gpadl_ring::AlignedGpadlView;
-use vmbus_channel::gpadl_ring::GpadlRingMem;
 use vmbus_core::HvsockConnectRequest;
 use vmbus_core::HvsockConnectResult;
 use vmbus_core::MaxVersionInfo;
@@ -1396,16 +1395,17 @@ impl ServerTask {
         in_gpadl: AlignedGpadlView,
         guest_to_host_event: Option<&ChannelEvent>,
         host_to_guest_interrupt: &Interrupt,
-    ) -> Result<(), anyhow::Error> {
-        let incoming_mem = GpadlRingMem::new(in_gpadl, gm)?;
+    ) -> anyhow::Result<()> {
+        let control_page = lock_gpn_with_subrange(gm, in_gpadl.gpns()[0])?;
         if let Some(guest_to_host_event) = guest_to_host_event {
-            if ring::reader_needs_signal(&incoming_mem) {
+            if ring::reader_needs_signal(control_page.pages()[0]) {
                 tracelimit::info_ratelimited!(channel = %channel.key, "waking host for incoming ring");
                 guest_to_host_event.0.deliver();
             }
         }
 
-        if ring::writer_needs_signal(&incoming_mem) {
+        let ring_size = gpadl_ring_size(&in_gpadl).try_into()?;
+        if ring::writer_needs_signal(control_page.pages()[0], ring_size) {
             tracelimit::info_ratelimited!(channel = %channel.key, "waking guest for incoming ring");
             host_to_guest_interrupt.deliver();
         }
@@ -1418,14 +1418,16 @@ impl ServerTask {
         out_gpadl: AlignedGpadlView,
         guest_to_host_event: Option<&ChannelEvent>,
         host_to_guest_interrupt: &Interrupt,
-    ) -> Result<(), anyhow::Error> {
-        let outgoing_mem = GpadlRingMem::new(out_gpadl, gm)?;
-        if ring::reader_needs_signal(&outgoing_mem) {
+    ) -> anyhow::Result<()> {
+        let control_page = lock_gpn_with_subrange(gm, out_gpadl.gpns()[0])?;
+        if ring::reader_needs_signal(control_page.pages()[0]) {
             tracelimit::info_ratelimited!(channel = %channel.key, "waking guest for outgoing ring");
             host_to_guest_interrupt.deliver();
         }
+
         if let Some(guest_to_host_event) = guest_to_host_event {
-            if ring::writer_needs_signal(&outgoing_mem) {
+            let ring_size = gpadl_ring_size(&out_gpadl).try_into()?;
+            if ring::writer_needs_signal(control_page.pages()[0], ring_size) {
                 tracelimit::info_ratelimited!(channel = %channel.key, "waking host for outgoing ring");
                 guest_to_host_event.0.deliver();
             }
@@ -2077,17 +2079,20 @@ fn inspect_rings(
 fn inspect_ring(req: inspect::Request<'_>, gpadl: &AlignedGpadlView, gm: &GuestMemory) {
     let mut resp = req.respond();
 
-    // Data size excluding the control page.
-    let ring_size = (gpadl.gpns().len() - 1) * PAGE_SIZE;
-    resp.hex("ring_size", ring_size);
+    resp.hex("ring_size", gpadl_ring_size(gpadl));
 
     // Lock just the control page. Use a subrange to allow a GuestMemory without a full mapping to
     // create one.
-    if let Ok(pages) = lock_page_with_subrange(gm, gpadl.gpns()[0] * PAGE_SIZE as u64) {
+    if let Ok(pages) = lock_gpn_with_subrange(gm, gpadl.gpns()[0]) {
         ring::inspect_ring(pages.pages()[0], &mut resp);
     }
 }
 
+fn gpadl_ring_size(gpadl: &AlignedGpadlView) -> usize {
+    // Data size excluding the control page.
+    (gpadl.gpns().len() - 1) * PAGE_SIZE
+}
+
 /// Helper to create a subrange before locking a single page.
 ///
 /// This allows us to lock a page in a `GuestMemory` that doesn't have a full mapping, but can
@@ -2098,6 +2103,14 @@ fn lock_page_with_subrange(gm: &GuestMemory, offset: u64) -> anyhow::Result<gues
         .lock_gpns(false, &[0])?)
 }
 
+/// Helper to create a subrange before locking a single page from a gpn.
+///
+/// This allows us to lock a page in a `GuestMemory` that doesn't have a full mapping, but can
+/// create one for a subrange.
+fn lock_gpn_with_subrange(gm: &GuestMemory, gpn: u64) -> anyhow::Result<guestmem::LockedPages> {
+    lock_page_with_subrange(gm, gpn * PAGE_SIZE as u64)
+}
+
 pub(crate) struct MessageSender {
     send: mpsc::Sender<SynicMessage>,
     multiclient: bool,