guest_memory: let multiple regions slice one global bitmap

QEMU uses a global bitmap, with each RAM region using an offset into
it.  This could be easily represented if bitmap() returned a
BaseSlice<&'static GlobalBitmap>, but there is a problem: bitmap()
currently wants to return a reference to the bitmap!

So change it to always return a slice.  This is more flexible, and
it isn't a performance problem because BitmapSlices are meant to be cheap
wrappers around a reference or Arc<>

Signed-off-by: Paolo Bonzini <[email protected]>

Author: bonzini

src/bitmap/mod.rs

@@ -293,13 +293,13 @@ pub(crate) mod tests {
 
         let slice = region.get_slice(dirty_addr, dirty_len).unwrap();
 
-        assert!(range_is_clean(region.bitmap(), 0, region.len() as usize));
+        assert!(range_is_clean(&region.bitmap(), 0, region.len() as usize));
         assert!(range_is_clean(slice.bitmap(), 0, dirty_len));
 
         region.write_obj(val, dirty_addr).unwrap();
 
         assert!(range_is_dirty(
-            region.bitmap(),
+            &region.bitmap(),
             dirty_addr.0 as usize,
             dirty_len
         ));
@@ -312,7 +312,7 @@ pub(crate) mod tests {
         test_bytes(
             region,
             |r: &R, start: usize, len: usize, clean: bool| {
-                check_range(r.bitmap(), start, len, clean)
+                check_range(&r.bitmap(), start, len, clean)
             },
             |offset| MemoryRegionAddress(offset as u64),
             0x1000,
@@ -334,13 +334,13 @@ pub(crate) mod tests {
         let (region, region_addr) = m.to_region_addr(dirty_addr).unwrap();
         let slice = m.get_slice(dirty_addr, dirty_len).unwrap();
 
-        assert!(range_is_clean(region.bitmap(), 0, region.len() as usize));
+        assert!(range_is_clean(&region.bitmap(), 0, region.len() as usize));
         assert!(range_is_clean(slice.bitmap(), 0, dirty_len));
 
         m.write_obj(val, dirty_addr).unwrap();
 
         assert!(range_is_dirty(
-            region.bitmap(),
+            &region.bitmap(),
             region_addr.0 as usize,
             dirty_len
         ));
@@ -354,7 +354,7 @@ pub(crate) mod tests {
         let check_range_closure = |m: &M, start: usize, len: usize, clean: bool| -> bool {
             let mut check_result = true;
             m.try_access(len, GuestAddress(start as u64), |_, size, reg_addr, reg| {
-                if !check_range(reg.bitmap(), reg_addr.0 as usize, size, clean) {
+                if !check_range(&reg.bitmap(), reg_addr.0 as usize, size, clean) {
                     check_result = false;
                 }
                 Ok(size)

src/guest_memory.rs

@@ -177,7 +177,7 @@ pub trait GuestMemoryRegion: Bytes<MemoryRegionAddress, E = Error> {
     }
 
     /// Borrow the associated `Bitmap` object.
-    fn bitmap(&self) -> &Self::B;
+    fn bitmap(&self) -> BS<'_, Self::B>;
 
     /// Returns the given address if it is within this region.
     fn check_address(&self, addr: MemoryRegionAddress) -> Option<MemoryRegionAddress> {

src/mmap/mod.rs

@@ -327,8 +327,8 @@ impl<B: Bitmap> GuestMemoryRegion for GuestRegionMmap<B> {
         self.guest_base
     }
 
-    fn bitmap(&self) -> &Self::B {
-        self.mapping.bitmap()
+    fn bitmap(&self) -> BS<'_, Self::B> {
+        self.mapping.bitmap().slice_at(0)
     }
 
     fn get_host_address(&self, addr: MemoryRegionAddress) -> guest_memory::Result<*mut u8> {