vhost: Add support for Xen memory mappings

vireshk · jiangliu · commit 4029089f7531 · 2023-07-05T16:49:12.000+08:00
The vm-memory crate now supports Xen specific memory mappings via a
special feature: "xen".

Add a corresponding feature for vhost crate and add support for Xen
memory regions. Update various dependencies to align to the same version
of vm-memory crate.

Signed-off-by: Viresh Kumar &lt;viresh.kumar@linaro.org&gt;
diff --git a/crates/vhost/Cargo.toml b/crates/vhost/Cargo.toml
@@ -23,15 +23,16 @@ vhost-net = ["vhost-kern"]
 vhost-user = []
 vhost-user-master = ["vhost-user"]
 vhost-user-slave = ["vhost-user"]
+xen = ["vm-memory/xen"]
 
 [dependencies]
 bitflags = "1.0"
 libc = "0.2.39"
 
 vmm-sys-util = "0.11.0"
-vm-memory = "0.11.0"
+vm-memory = "0.12.0"
 
 [dev-dependencies]
 tempfile = "3.2.0"
-vm-memory = { version = "0.11.0", features=["backend-mmap"] }
+vm-memory = { version = "0.12.0", features=["backend-mmap"] }
 serial_test = "0.5"
diff --git a/crates/vhost/README.md b/crates/vhost/README.md
@@ -30,3 +30,15 @@ The protocol defines two sides of the communication, master and slave.
 Master is the application that shares its virtqueues, slave is the consumer
 of the virtqueues. Master and slave can be either a client (i.e. connecting)
 or server (listening) in the socket communication.
+
+## Xen support
+
+Supporting Xen requires special handling while mapping the guest memory. The
+`vm-memory` crate implements xen memory mapping support via a separate feature
+`xen`, and this crate uses the same feature name to enable Xen support.
+
+Also, for xen mappings, the memory regions passed by the frontend contains few
+extra fields as described in the vhost-user protocol documentation.
+
+It was decided by the `rust-vmm` maintainers to keep the interface simple and
+build the crate for either standard Unix memory mapping or Xen, and not both.
diff --git a/crates/vhost/src/backend.rs b/crates/vhost/src/backend.rs
@@ -10,12 +10,15 @@
 //! Common traits and structs for vhost-kern and vhost-user backend drivers.
 
 use std::cell::RefCell;
+use std::os::unix::io::AsRawFd;
 use std::os::unix::io::RawFd;
 use std::sync::RwLock;
 
+use vm_memory::{bitmap::Bitmap, Address, GuestMemoryRegion, GuestRegionMmap};
 use vmm_sys_util::eventfd::EventFd;
 
-use super::Result;
+use super::vhost_user::message::{VhostUserMemoryRegion, VhostUserSingleMemoryRegion};
+use super::{Error, Result};
 
 /// Maximum number of memory regions supported.
 pub const VHOST_MAX_MEMORY_REGIONS: usize = 255;
@@ -72,6 +75,70 @@ pub struct VhostUserMemoryRegionInfo {
     pub mmap_offset: u64,
     /// Optional file descriptor for mmap.
     pub mmap_handle: RawFd,
+
+    #[cfg(feature = "xen")]
+    /// Xen specific flags.
+    pub xen_mmap_flags: u32,
+
+    #[cfg(feature = "xen")]
+    /// Xen specific data.
+    pub xen_mmap_data: u32,
+}
+
+impl VhostUserMemoryRegionInfo {
+    /// Creates Self from GuestRegionMmap.
+    pub fn from_guest_region<B: Bitmap>(region: &GuestRegionMmap<B>) -> Result<Self> {
+        let file_offset = region
+            .file_offset()
+            .ok_or(Error::InvalidGuestMemoryRegion)?;
+
+        Ok(Self {
+            guest_phys_addr: region.start_addr().raw_value(),
+            memory_size: region.len(),
+            userspace_addr: region.as_ptr() as u64,
+            mmap_offset: file_offset.start(),
+            mmap_handle: file_offset.file().as_raw_fd(),
+            #[cfg(feature = "xen")]
+            xen_mmap_flags: region.xen_mmap_flags(),
+            #[cfg(feature = "xen")]
+            xen_mmap_data: region.xen_mmap_data(),
+        })
+    }
+
+    /// Creates VhostUserMemoryRegion from Self.
+    pub fn to_region(&self) -> VhostUserMemoryRegion {
+        #[cfg(not(feature = "xen"))]
+        return VhostUserMemoryRegion::new(
+            self.guest_phys_addr,
+            self.memory_size,
+            self.userspace_addr,
+            self.mmap_offset,
+        );
+
+        #[cfg(feature = "xen")]
+        VhostUserMemoryRegion::with_xen(
+            self.guest_phys_addr,
+            self.memory_size,
+            self.userspace_addr,
+            self.mmap_offset,
+            self.xen_mmap_flags,
+            self.xen_mmap_data,
+        )
+    }
+
+    /// Creates VhostUserSingleMemoryRegion from Self.
+    pub fn to_single_region(&self) -> VhostUserSingleMemoryRegion {
+        VhostUserSingleMemoryRegion::new(
+            self.guest_phys_addr,
+            self.memory_size,
+            self.userspace_addr,
+            self.mmap_offset,
+            #[cfg(feature = "xen")]
+            self.xen_mmap_flags,
+            #[cfg(feature = "xen")]
+            self.xen_mmap_data,
+        )
+    }
 }
 
 /// Shared memory region data for logging dirty pages
@@ -460,6 +527,11 @@ impl VhostUserMemoryRegionInfo {
             userspace_addr,
             mmap_offset,
             mmap_handle,
+
+            #[cfg(feature = "xen")]
+            xen_mmap_flags: vm_memory::MmapXenFlags::UNIX.bits(),
+            #[cfg(feature = "xen")]
+            xen_mmap_data: 0,
         }
     }
 }
diff --git a/crates/vhost/src/vhost_user/master.rs b/crates/vhost/src/vhost_user/master.rs
@@ -193,13 +193,8 @@ impl VhostBackend for Master {
             if region.memory_size == 0 || region.mmap_handle < 0 {
                 return error_code(VhostUserError::InvalidParam);
             }
-            let reg = VhostUserMemoryRegion {
-                guest_phys_addr: region.guest_phys_addr,
-                memory_size: region.memory_size,
-                user_addr: region.userspace_addr,
-                mmap_offset: region.mmap_offset,
-            };
-            ctx.append(&reg, region.mmap_handle);
+
+            ctx.append(&region.to_region(), region.mmap_handle);
         }
 
         let mut node = self.node();
@@ -501,12 +496,7 @@ impl VhostUserMaster for Master {
             return error_code(VhostUserError::InvalidParam);
         }
 
-        let body = VhostUserSingleMemoryRegion::new(
-            region.guest_phys_addr,
-            region.memory_size,
-            region.userspace_addr,
-            region.mmap_offset,
-        );
+        let body = region.to_single_region();
         let fds = [region.mmap_handle];
         let hdr = node.send_request_with_body(MasterReq::ADD_MEM_REG, &body, Some(&fds))?;
         node.wait_for_ack(&hdr).map_err(|e| e.into())
@@ -519,12 +509,7 @@ impl VhostUserMaster for Master {
             return error_code(VhostUserError::InvalidParam);
         }
 
-        let body = VhostUserSingleMemoryRegion::new(
-            region.guest_phys_addr,
-            region.memory_size,
-            region.userspace_addr,
-            region.mmap_offset,
-        );
+        let body = region.to_single_region();
         let hdr = node.send_request_with_body(MasterReq::REM_MEM_REG, &body, None)?;
         node.wait_for_ack(&hdr).map_err(|e| e.into())
     }
diff --git a/crates/vhost/src/vhost_user/message.rs b/crates/vhost/src/vhost_user/message.rs
@@ -10,10 +10,15 @@
 #![allow(clippy::upper_case_acronyms)]
 
 use std::fmt::Debug;
+use std::fs::File;
+use std::io;
 use std::marker::PhantomData;
 use std::ops::Deref;
 
-use vm_memory::ByteValued;
+use vm_memory::{mmap::NewBitmap, ByteValued, Error as MmapError, FileOffset, MmapRegion};
+
+#[cfg(feature = "xen")]
+use vm_memory::{GuestAddress, MmapRange, MmapXenFlags};
 
 use super::{Error, Result};
 use crate::VringConfigData;
@@ -422,6 +427,8 @@ bitflags! {
         const CONFIGURE_MEM_SLOTS = 0x0000_8000;
         /// Support reporting status.
         const STATUS = 0x0001_0000;
+        /// Support Xen mmap.
+        const XEN_MMAP = 0x0002_0000;
     }
 }
 
@@ -492,8 +499,26 @@ pub struct VhostUserMemoryRegion {
     pub user_addr: u64,
     /// Offset where region starts in the mapped memory.
     pub mmap_offset: u64,
+
+    #[cfg(feature = "xen")]
+    /// Xen specific flags.
+    pub xen_mmap_flags: u32,
+
+    #[cfg(feature = "xen")]
+    /// Xen specific data.
+    pub xen_mmap_data: u32,
+}
+
+impl VhostUserMemoryRegion {
+    fn is_valid_common(&self) -> bool {
+        self.memory_size != 0
+            && self.guest_phys_addr.checked_add(self.memory_size).is_some()
+            && self.user_addr.checked_add(self.memory_size).is_some()
+            && self.mmap_offset.checked_add(self.memory_size).is_some()
+    }
 }
 
+#[cfg(not(feature = "xen"))]
 impl VhostUserMemoryRegion {
     /// Create a new instance.
     pub fn new(guest_phys_addr: u64, memory_size: u64, user_addr: u64, mmap_offset: u64) -> Self {
@@ -504,18 +529,74 @@ impl VhostUserMemoryRegion {
             mmap_offset,
         }
     }
+
+    /// Creates mmap region from Self.
+    pub fn mmap_region<B: NewBitmap>(&self, file: File) -> Result<MmapRegion<B>> {
+        MmapRegion::<B>::from_file(
+            FileOffset::new(file, self.mmap_offset),
+            self.memory_size as usize,
+        )
+        .map_err(MmapError::MmapRegion)
+        .map_err(|e| Error::ReqHandlerError(io::Error::new(io::ErrorKind::Other, e)))
+    }
+
+    fn is_valid(&self) -> bool {
+        self.is_valid_common()
+    }
 }
 
-impl VhostUserMsgValidator for VhostUserMemoryRegion {
+#[cfg(feature = "xen")]
+impl VhostUserMemoryRegion {
+    /// Create a new instance.
+    pub fn with_xen(
+        guest_phys_addr: u64,
+        memory_size: u64,
+        user_addr: u64,
+        mmap_offset: u64,
+        xen_mmap_flags: u32,
+        xen_mmap_data: u32,
+    ) -> Self {
+        VhostUserMemoryRegion {
+            guest_phys_addr,
+            memory_size,
+            user_addr,
+            mmap_offset,
+            xen_mmap_flags,
+            xen_mmap_data,
+        }
+    }
+
+    /// Creates mmap region from Self.
+    pub fn mmap_region<B: NewBitmap>(&self, file: File) -> Result<MmapRegion<B>> {
+        let range = MmapRange::new(
+            self.memory_size as usize,
+            Some(FileOffset::new(file, self.mmap_offset)),
+            GuestAddress(self.guest_phys_addr),
+            self.xen_mmap_flags,
+            self.xen_mmap_data,
+        );
+
+        MmapRegion::<B>::from_range(range)
+            .map_err(MmapError::MmapRegion)
+            .map_err(|e| Error::ReqHandlerError(io::Error::new(io::ErrorKind::Other, e)))
+    }
+
     fn is_valid(&self) -> bool {
-        if self.memory_size == 0
-            || self.guest_phys_addr.checked_add(self.memory_size).is_none()
-            || self.user_addr.checked_add(self.memory_size).is_none()
-            || self.mmap_offset.checked_add(self.memory_size).is_none()
-        {
-            return false;
+        if !self.is_valid_common() {
+            false
+        } else {
+            // Only of one of FOREIGN or GRANT should be set.
+            match MmapXenFlags::from_bits(self.xen_mmap_flags) {
+                Some(flags) => flags.is_valid(),
+                None => false,
+            }
         }
-        true
+    }
+}
+
+impl VhostUserMsgValidator for VhostUserMemoryRegion {
+    fn is_valid(&self) -> bool {
+        self.is_valid()
     }
 }
 
@@ -541,6 +622,7 @@ impl Deref for VhostUserSingleMemoryRegion {
     }
 }
 
+#[cfg(not(feature = "xen"))]
 impl VhostUserSingleMemoryRegion {
     /// Create a new instance.
     pub fn new(guest_phys_addr: u64, memory_size: u64, user_addr: u64, mmap_offset: u64) -> Self {
@@ -556,6 +638,31 @@ impl VhostUserSingleMemoryRegion {
     }
 }
 
+#[cfg(feature = "xen")]
+impl VhostUserSingleMemoryRegion {
+    /// Create a new instance.
+    pub fn new(
+        guest_phys_addr: u64,
+        memory_size: u64,
+        user_addr: u64,
+        mmap_offset: u64,
+        xen_mmap_flags: u32,
+        xen_mmap_data: u32,
+    ) -> Self {
+        VhostUserSingleMemoryRegion {
+            padding: 0,
+            region: VhostUserMemoryRegion::with_xen(
+                guest_phys_addr,
+                memory_size,
+                user_addr,
+                mmap_offset,
+                xen_mmap_flags,
+                xen_mmap_data,
+            ),
+        }
+    }
+}
+
 // SAFETY: Safe because all fields of VhostUserSingleMemoryRegion are POD.
 unsafe impl ByteValued for VhostUserSingleMemoryRegion {}
 impl VhostUserMsgValidator for VhostUserSingleMemoryRegion {}
@@ -1001,6 +1108,20 @@ mod tests {
     use super::*;
     use std::mem;
 
+    #[cfg(feature = "xen")]
+    impl VhostUserMemoryRegion {
+        fn new(guest_phys_addr: u64, memory_size: u64, user_addr: u64, mmap_offset: u64) -> Self {
+            Self::with_xen(
+                guest_phys_addr,
+                memory_size,
+                user_addr,
+                mmap_offset,
+                MmapXenFlags::FOREIGN.bits(),
+                0,
+            )
+        }
+    }
+
     #[test]
     fn check_master_request_code() {
         assert!(!MasterReq::is_valid(MasterReq::NOOP as _));
@@ -1106,12 +1227,7 @@ mod tests {
 
     #[test]
     fn check_user_memory_region() {
-        let mut msg = VhostUserMemoryRegion {
-            guest_phys_addr: 0,
-            memory_size: 0x1000,
-            user_addr: 0,
-            mmap_offset: 0,
-        };
+        let mut msg = VhostUserMemoryRegion::new(0, 0x1000, 0, 0);
         assert!(msg.is_valid());
         msg.guest_phys_addr = 0xFFFFFFFFFFFFEFFF;
         assert!(msg.is_valid());
diff --git a/crates/vhost/src/vhost_user/mod.rs b/crates/vhost/src/vhost_user/mod.rs
diff --git a/crates/vhost/src/vhost_user/slave_req_handler.rs b/crates/vhost/src/vhost_user/slave_req_handler.rs
