add dirty bitmap tracking abstractions

Signed-off-by: Alexandru Agache <[email protected]>

Author: alexandruag

src/bitmap.rs

@@ -0,0 +1,86 @@
+//! This module holds abstractions that enable tracking the areas dirtied by writes of a specified
+//! length to a given offset. In particular, this is used to track write accesses within a
+//! `GuestMemoryRegion` object, and the resulting bitmaps can then be aggregated to build the
+//! global view for an entire `GuestMemory` object.
+
+use std::fmt::Debug;
+
+use crate::{GuestMemory, GuestMemoryRegion};
+
+/// Trait implemented by types that support creating `BitmapSlice` objects.
+pub trait WithBitmapSlice<'a> {
+    /// Type of the bitmap slice.
+    type S: BitmapSlice;
+}
+
+/// Trait used to represent that a `BitmapSlice` is a `Bitmap` itself, but also satisfies the
+/// restriction that slices created from it have the same type as `Self`.
+pub trait BitmapSlice:
+    Bitmap + Copy + Clone + Debug + for<'a> WithBitmapSlice<'a, S = Self>
+{
+}
+
+/// Common bitmap operations. Using HRTBs to effectively define an associated type that
+/// has a lifetime parameter, without tagging the `Bitmap` trait with a lifetime as well.
+///
+/// Using an associated type allows implementing the `Bitmap` and `BitmapSlice` functionality
+/// as a zero-cost abstraction, when providing trivial implementations such as the one
+/// defined for `()`.
+// This is just an initial proposal; we'll add other methods if they need to be part of the main
+// interface as well.
+pub trait Bitmap: for<'a> WithBitmapSlice<'a> {
+    /// Mark the memory range specified by the given `offset` and `len` as dirtied.
+    fn mark_dirty(&self, offset: usize, len: usize);
+
+    /// Return a `Self::S::Slice` of the current bitmap, starting at the specified `offset`.
+    fn slice_at(&self, offset: usize) -> <Self as WithBitmapSlice>::S;
+}
+
+/// A no-op `Bitmap` implementation that can be provided for backends that do not actually
+/// require the tracking functionality.
+
+impl<'a> WithBitmapSlice<'a> for () {
+    type S = Self;
+}
+
+impl BitmapSlice for () {}
+
+impl Bitmap for () {
+    fn mark_dirty(&self, _offset: usize, _len: usize) {}
+
+    fn slice_at(&self, _offset: usize) -> Self {}
+}
+
+/// A `Bitmap` and `BitmapSlice` implementation for `Option<B>`.
+
+impl<'a, B> WithBitmapSlice<'a> for Option<B>
+where
+    B: WithBitmapSlice<'a>,
+{
+    type S = Option<B::S>;
+}
+
+impl<B: BitmapSlice> BitmapSlice for Option<B> {}
+
+impl<B: Bitmap> Bitmap for Option<B> {
+    fn mark_dirty(&self, offset: usize, len: usize) {
+        if let Some(inner) = self {
+            inner.mark_dirty(offset, len)
+        }
+    }
+
+    fn slice_at(&self, offset: usize) -> Option<<B as WithBitmapSlice>::S> {
+        if let Some(inner) = self {
+            return Some(inner.slice_at(offset));
+        }
+        None
+    }
+}
+
+/// Helper type alias for referring to the `BitmapSlice` concrete type associated with
+/// an object `B: WithBitmapSlice<'a>`.
+pub type BS<'a, B> = <B as WithBitmapSlice<'a>>::S;
+
+/// Helper type alias for referring to the `BitmapSlice` concrete type associated with
+/// the memory regions of an object `M: GuestMemory`.
+pub type MS<'a, M> = BS<'a, <<M as GuestMemory>::R as GuestMemoryRegion>::B>;

src/bytes.rs

@@ -18,7 +18,6 @@ use std::slice::{from_raw_parts, from_raw_parts_mut};
 use std::sync::atomic::Ordering;
 
 use crate::atomic_integer::AtomicInteger;
-use crate::VolatileSlice;
 
 /// Types for which it is safe to initialize from raw data.
 ///
@@ -105,22 +104,6 @@ pub unsafe trait ByteValued: Copy + Default + Send + Sync {
         // borrowing the given mutable reference.
         unsafe { from_raw_parts_mut(self as *mut Self as *mut u8, size_of::<Self>()) }
     }
-
-    /// Converts a mutable reference to `self` into a `VolatileSlice`.  This is
-    /// useful because `VolatileSlice` provides a `Bytes<usize>` implementation.
-    ///
-    /// # Safety
-    ///
-    /// Unlike most `VolatileMemory` implementation, this method requires an exclusive
-    /// reference to `self`; this trivially fulfills `VolatileSlice::new`'s requirement
-    /// that all accesses to `self` use volatile accesses (because there can
-    /// be no other accesses).
-    fn as_bytes(&mut self) -> VolatileSlice {
-        unsafe {
-            // This is safe because the lifetime is the same as self
-            VolatileSlice::new(self as *mut Self as usize as *mut _, size_of::<Self>())
-        }
-    }
 }
 
 // All intrinsic types and arrays of intrinsic types are ByteValued. They are just numbers.

src/guest_memory.rs

@@ -43,8 +43,9 @@ use std::sync::atomic::Ordering;
 use std::sync::Arc;
 
 use crate::address::{Address, AddressValue};
+use crate::bitmap::{Bitmap, BS, MS};
 use crate::bytes::{AtomicAccess, Bytes};
-use crate::volatile_memory;
+use crate::volatile_memory::{self, VolatileSlice};
 
 static MAX_ACCESS_CHUNK: usize = 4096;
 
@@ -165,6 +166,9 @@ impl FileOffset {
 /// Represents a continuous region of guest physical memory.
 #[allow(clippy::len_without_is_empty)]
 pub trait GuestMemoryRegion: Bytes<MemoryRegionAddress, E = Error> {
+    /// Type used for dirty memory tracking.
+    type B: Bitmap;
+
     /// Returns the size of the region.
     fn len(&self) -> GuestUsize;
 
@@ -177,6 +181,9 @@ pub trait GuestMemoryRegion: Bytes<MemoryRegionAddress, E = Error> {
         self.start_addr().unchecked_add(self.len() - 1)
     }
 
+    /// Borrow the associated `Bitmap` object.
+    fn bitmap(&self) -> &Self::B;
+
     /// Returns the given address if it is within this region.
     fn check_address(&self, addr: MemoryRegionAddress) -> Option<MemoryRegionAddress> {
         if self.address_in_range(addr) {
@@ -257,7 +264,7 @@ pub trait GuestMemoryRegion: Bytes<MemoryRegionAddress, E = Error> {
         &self,
         offset: MemoryRegionAddress,
         count: usize,
-    ) -> Result<volatile_memory::VolatileSlice> {
+    ) -> Result<VolatileSlice<BS<Self::B>>> {
         Err(Error::HostAddressNotAvailable)
     }
 
@@ -286,7 +293,7 @@ pub trait GuestMemoryRegion: Bytes<MemoryRegionAddress, E = Error> {
     /// assert_eq!(r.load(), v);
     /// # }
     /// ```
-    fn as_volatile_slice(&self) -> Result<volatile_memory::VolatileSlice> {
+    fn as_volatile_slice(&self) -> Result<VolatileSlice<BS<Self::B>>> {
         self.get_slice(MemoryRegionAddress(0), self.len() as usize)
     }
 
@@ -702,11 +709,7 @@ pub trait GuestMemory {
 
     /// Returns a [`VolatileSlice`](struct.VolatileSlice.html) of `count` bytes starting at
     /// `addr`.
-    fn get_slice(
-        &self,
-        addr: GuestAddress,
-        count: usize,
-    ) -> Result<volatile_memory::VolatileSlice> {
+    fn get_slice(&self, addr: GuestAddress, count: usize) -> Result<VolatileSlice<MS<Self>>> {
         self.to_region_addr(addr)
             .ok_or(Error::InvalidGuestAddress(addr))
             .and_then(|(r, addr)| r.get_slice(addr, count))

src/lib.rs

@@ -31,6 +31,8 @@ pub use atomic::{GuestMemoryAtomic, GuestMemoryLoadGuard};
 mod atomic_integer;
 pub use atomic_integer::AtomicInteger;
 
+pub mod bitmap;
+
 pub mod bytes;
 pub use bytes::{AtomicAccess, ByteValued, Bytes};