vfio_assigned_device: dynamic IOMMU mapping for P2P DMA (#3367)

VFIO device assignment needs peer-to-peer DMA between assigned devices —
one device must be able to DMA into another device's BAR. The old VFIO
container manager snapshot guest RAM at creation time via
GuestMemory::full_mapping() and programmed a static set of IOMMU
identity mappings, so device BARs (which are mapped dynamically as the
guest configures them) were never visible to the IOMMU.

Introduce a DmaTarget trait in the region manager that receives
incremental sub-mapping events (map_dma / unmap_dma) as regions are
enabled, disabled, or modified. VFIO containers register themselves as
DMA mapper consumers via a new DmaMapperClient, and the region manager
replays all existing active sub-mappings on registration, then sends
live updates as the memory map evolves. This means device BAR mappings
are now programmed into every VFIO container's IOMMU as they appear,
enabling P2P DMA between assigned devices.

The region manager maintains the VaMapper lifecycle for backends that
need host VAs (VFIO type1's pin_user_pages), controlled by a needs_va
flag at registration. This also sets up the abstraction for future
iommufd support, which maps from fd+offset directly and won't need a
VaMapper at all.

Author: jstarks

Cargo.lock

@@ -8704,6 +8704,7 @@ dependencies = [
  "chipset_device",
  "guestmem",
  "inspect",
+ "membacking",
  "memory_range",
  "mesh",
  "pal_async",

openvmm/membacking/src/lib.rs

@@ -88,6 +88,7 @@ mod sys {
 /// On Unix, this is an empty (uninhabitable) enum.
 pub type RemoteProcess = sys::RemoteProcess;
 
+pub use mapping_manager::Mappable;
 pub use memory_manager::DeviceMemoryMapper;
 pub use memory_manager::GuestMemoryBuilder;
 pub use memory_manager::GuestMemoryClient;
@@ -97,3 +98,6 @@ pub use memory_manager::PartitionAttachError;
 pub use memory_manager::RamVisibility;
 pub use memory_manager::RamVisibilityControl;
 pub use memory_manager::SharedMemoryBacking;
+pub use region_manager::DmaMapperClient;
+pub use region_manager::DmaMapperHandle;
+pub use region_manager::DmaTarget;

openvmm/membacking/src/mapping_manager/va_mapper.rs

@@ -44,6 +44,10 @@ use std::sync::Arc;
 use std::thread::JoinHandle;
 use thiserror::Error;
 
+/// A virtual address space mapper for guest memory.
+///
+/// Maintains a reserved VA range and maps file-backed or anonymous memory
+/// into it as directed by the mapping manager.
 pub struct VaMapper {
     inner: Arc<MapperInner>,
     process: Option<RemoteProcess>,
@@ -259,14 +263,17 @@ impl VaMapper {
         self.inner.request_mapping(range, false).await
     }
 
+    /// Returns the base pointer of the VA reservation.
     pub fn as_ptr(&self) -> *mut u8 {
         self.inner.mapping.as_ptr().cast()
     }
 
+    /// Returns the length of the VA reservation in bytes.
     pub fn len(&self) -> usize {
         self.inner.mapping.len()
     }
 
+    /// Returns the remote process, if this mapper maps into a remote process.
     pub fn process(&self) -> Option<&RemoteProcess> {
         self.process.as_ref()
     }

openvmm/membacking/src/memory_manager/device_memory.rs

@@ -158,7 +158,10 @@ impl MappableGuestMemory for DeviceMemoryControl {
                     MemoryRange::try_from(gpa..gpa.wrapping_add(self.0.len as u64))
                         .map_err(|err| io::Error::new(io::ErrorKind::InvalidInput, err))?,
                     DEVICE_PRIORITY,
-                    false, // device memory cannot currently be a DMA target
+                    false, // not a DMA target: excludes device BARs from
+                           // GuestMemorySharing (vhost-user). IOMMU consumers
+                           // get notified of these mappings via the DmaMapper
+                           // path regardless of this flag.
                 )
                 .await
                 .map_err(io::Error::other)?;

openvmm/membacking/src/memory_manager/mod.rs

@@ -455,6 +455,11 @@ impl GuestMemoryManager {
         DeviceMemoryMapper::new(self.region_manager.client().clone())
     }
 
+    /// Returns a client for registering DMA mappers (VFIO, iommufd).
+    pub fn dma_mapper_client(&self) -> crate::region_manager::DmaMapperClient {
+        crate::region_manager::DmaMapperClient::new(self.region_manager.client())
+    }
+
     /// Returns an object for manipulating the visibility state of different RAM
     /// regions.
     pub fn ram_visibility_control(&self) -> RamVisibilityControl {