vm-memory: Add Xen memory mapping support

Xen allows two memory mapping mechanisms:
- Foreign mapping: entire guest space is mapped at once.
- Grant mapping: guest controls what backend is allowed to map.

Both these mechanisms required additional mapping support, for example
an ioctl() needs to be issued (with arguments passed from backend),
along with mmap().

Also for grant memory mapping, the mapping may or may not be done in
advance and may be required to be done on-demand. Support for that will
be added by a separate commit later.

Add memory mapping support for both these cases, under a new feature
"xen". Also add support to do generic Unix type mapping via Xen, in
absence of foreign or grant mapping, which will be used by test code for
other modules.

Signed-off-by: Viresh Kumar <[email protected]>

Author: vireshk

Cargo.toml

@@ -16,11 +16,14 @@ default = []
 backend-bitmap = []
 backend-mmap = []
 backend-atomic = ["arc-swap"]
+xen = ["backend-mmap", "bitflags", "vmm-sys-util"]
 
 [dependencies]
 libc = "0.2.39"
 arc-swap = { version = "1.0.0", optional = true }
+bitflags = { version = "1.0", optional = true }
 thiserror = "1.0.40"
+vmm-sys-util = { version = "0.11.0", optional = true }
 
 [target.'cfg(windows)'.dependencies.winapi]
 version = "0.3"

src/lib.rs

@@ -45,16 +45,21 @@ pub use guest_memory::{
     GuestMemoryRegion, GuestUsize, MemoryRegionAddress, Result as GuestMemoryResult,
 };
 
-#[cfg(all(feature = "backend-mmap", unix))]
+#[cfg(all(feature = "backend-mmap", not(feature = "xen"), unix))]
 mod mmap_unix;
 
+#[cfg(all(feature = "backend-mmap", feature = "xen", unix))]
+mod mmap_xen;
+
 #[cfg(all(feature = "backend-mmap", windows))]
 mod mmap_windows;
 
 #[cfg(feature = "backend-mmap")]
 pub mod mmap;
 #[cfg(feature = "backend-mmap")]
 pub use mmap::{Error, GuestMemoryMmap, GuestRegionMmap, MmapRegion};
+#[cfg(all(feature = "backend-mmap", feature = "xen", unix))]
+pub use mmap::{MmapRange, MmapXenFlags};
 
 pub mod volatile_memory;
 pub use volatile_memory::{

src/mmap.rs

@@ -30,9 +30,12 @@ use crate::guest_memory::{
 use crate::volatile_memory::{VolatileMemory, VolatileSlice};
 use crate::{AtomicAccess, Bytes};
 
-#[cfg(unix)]
+#[cfg(all(not(feature = "xen"), unix))]
 pub use crate::mmap_unix::{Error as MmapRegionError, MmapRegion, MmapRegionBuilder};
 
+#[cfg(all(feature = "xen", unix))]
+pub use crate::mmap_xen::{Error as MmapRegionError, MmapRange, MmapRegion, MmapXenFlags};
+
 #[cfg(windows)]
 pub use crate::mmap_windows::MmapRegion;
 #[cfg(windows)]
@@ -130,6 +133,7 @@ impl<B: Bitmap> GuestRegionMmap<B> {
     }
 }
 
+#[cfg(not(feature = "xen"))]
 impl<B: NewBitmap> GuestRegionMmap<B> {
     /// Create a new memory-mapped memory region from guest's physical memory, size and file.
     pub fn from_range(
@@ -148,6 +152,22 @@ impl<B: NewBitmap> GuestRegionMmap<B> {
     }
 }
 
+#[cfg(feature = "xen")]
+impl<B: NewBitmap> GuestRegionMmap<B> {
+    /// Create a new Unix memory-mapped memory region from guest's physical memory, size and file.
+    /// This must only be used for tests, doctests, benches and is not designed for end consumers.
+    pub fn from_range(
+        addr: GuestAddress,
+        size: usize,
+        file: Option<FileOffset>,
+    ) -> result::Result<Self, Error> {
+        let range = MmapRange::new_unix(size, file, addr);
+
+        let region = MmapRegion::from_range(range).map_err(Error::MmapRegion)?;
+        Self::new(region, addr)
+    }
+}
+
 impl<B: Bitmap> Bytes<MemoryRegionAddress> for GuestRegionMmap<B> {
     type E = guest_memory::Error;