Bytes: Do not use to_region_addr()

When we switch to a (potentially) virtual memory model, we want to
compact the interface, especially removing references to memory regions
because virtual memory is not just split into regions, but pages first.

`to_region_addr()` will no longer work then, as it does not communicate
to the caller for how many bytes that mapping is valid.  (Currently, it
is generally valid until the end of the region, but this will not be the
case with virtual memory.)

So instead, get a `VolatileSlice` via `get_slices()` and do the atomic
access on it.

(Note: We cannot really have a test case for this, as right now, memory
fragmentation will only happen exactly at memory region boundaries.  In
this case, `region.load()` and `region.store()` would have already
returned errors.  This change is necessary for when page boundaries
result in different mappings within a single region, but because we
don’t have IOMMU support yet, this can’t be tested.)

Signed-off-by: Hanna Czenczek <[email protected]>

Author: XanClic

CHANGELOG.md

@@ -23,6 +23,7 @@
   and `GuestRegionMmap::from_range` to be separate from the error type returned by `GuestRegionCollection` functions.
   Change return type of `GuestRegionMmap::new` from `Result` to `Option`.
 - \[#324](https:////github.com/rust-vmm/vm-memory/pull/324)\] `GuestMemoryRegion::bitmap()` now returns a `BitmapSlice`. Accessing the full bitmap is now possible only if the type of the memory region is know, for example with `MmapRegion::bitmap()`.
+- \[[#339](https://github.com/rust-vmm/vm-memory/pull/339)\] Implement `Bytes::load()` and `Bytes::store()` with `get_slices()` instead of `to_region_addr()`
 
 ### Removed
 

src/guest_memory.rs

@@ -45,6 +45,7 @@ use std::convert::From;
 use std::fs::File;
 use std::io;
 use std::iter::FusedIterator;
+use std::mem::size_of;
 use std::ops::{BitAnd, BitOr, Deref};
 use std::rc::Rc;
 use std::sync::atomic::Ordering;
@@ -685,17 +686,23 @@ impl<T: GuestMemory + ?Sized> Bytes<GuestAddress> for T {
     }
 
     fn store<O: AtomicAccess>(&self, val: O, addr: GuestAddress, order: Ordering) -> Result<()> {
-        // `find_region` should really do what `to_region_addr` is doing right now, except
-        // it should keep returning a `Result`.
-        self.to_region_addr(addr)
-            .ok_or(Error::InvalidGuestAddress(addr))
-            .and_then(|(region, region_addr)| region.store(val, region_addr, order))
+        // No need to check past the first iterator item: It either has the size of `O`, then there
+        // can be no further items; or it does not, and then `VolatileSlice::store()` will fail.
+        self.get_slices(addr, size_of::<O>())
+            .next()
+            .unwrap()? // count > 0 never produces an empty iterator
+            .store(val, 0, order)
+            .map_err(Into::into)
     }
 
     fn load<O: AtomicAccess>(&self, addr: GuestAddress, order: Ordering) -> Result<O> {
-        self.to_region_addr(addr)
-            .ok_or(Error::InvalidGuestAddress(addr))
-            .and_then(|(region, region_addr)| region.load(region_addr, order))
+        // No need to check past the first iterator item: It either has the size of `O`, then there
+        // can be no further items; or it does not, and then `VolatileSlice::store()` will fail.
+        self.get_slices(addr, size_of::<O>())
+            .next()
+            .unwrap()? // count > 0 never produces an empty iterator
+            .load(0, order)
+            .map_err(Into::into)
     }
 }