relax trait bounds for AvailIter and DescriptorChain

We are using a `: GuestAddressSpace` trait bound for `AvailIter` and
`DescriptorChain`, but the objects are actually only interested in
the fact that `M` can dereference to something that implements
`GuestMemory` (which is trivially true for a reference to a `GuestMemory`
implementation, for example).

Signed-off-by: Alexandru Agache <aagch@amazon.com>

Author: alexandruag

crates/devices/virtio-blk/src/request.rs

@@ -24,6 +24,7 @@
 //! approach.
 
 use std::fmt::{self, Display};
+use std::ops::Deref;
 use std::result;
 
 use crate::defs::{
@@ -32,9 +33,7 @@ use crate::defs::{
 };
 
 use virtio_queue::{Descriptor, DescriptorChain};
-use vm_memory::{
-    ByteValued, Bytes, GuestAddress, GuestAddressSpace, GuestMemory, GuestMemoryError,
-};
+use vm_memory::{ByteValued, Bytes, GuestAddress, GuestMemory, GuestMemoryError};
 
 /// Block request parsing errors.
 #[derive(Debug)]
@@ -202,7 +201,11 @@ impl Request {
     /// # Arguments
     /// * `desc_chain` - A mutable reference to the descriptor chain that should point to the
     ///                  buffers of a virtio block request.
-    pub fn parse<M: GuestAddressSpace>(desc_chain: &mut DescriptorChain<M>) -> Result<Request> {
+    pub fn parse<M>(desc_chain: &mut DescriptorChain<M>) -> Result<Request>
+    where
+        M: Deref,
+        M::Target: GuestMemory + Sized,
+    {
         let chain_head = desc_chain.next().ok_or(Error::DescriptorChainTooShort)?;
         // The head contains the request type which MUST be readable.
         if chain_head.is_write_only() {
@@ -235,7 +238,7 @@ impl Request {
         }
         let status_desc = desc;
 
-        Request::check_status_desc::<<M>::M>(desc_chain.memory(), status_desc)?;
+        Request::check_status_desc(desc_chain.memory(), status_desc)?;
 
         request.status_addr = status_desc.addr();
         Ok(request)

crates/virtio-queue/src/lib.rs

@@ -147,8 +147,8 @@ unsafe impl ByteValued for Descriptor {}
 
 /// A virtio descriptor chain.
 #[derive(Clone, Debug)]
-pub struct DescriptorChain<M: GuestAddressSpace> {
-    mem: M::T,
+pub struct DescriptorChain<M> {
+    mem: M,
     desc_table: GuestAddress,
     queue_size: u16,
     head_index: u16,
@@ -157,9 +157,13 @@ pub struct DescriptorChain<M: GuestAddressSpace> {
     is_indirect: bool,
 }
 
-impl<M: GuestAddressSpace> DescriptorChain<M> {
+impl<M> DescriptorChain<M>
+where
+    M: Deref,
+    M::Target: GuestMemory,
+{
     fn with_ttl(
-        mem: M::T,
+        mem: M,
         desc_table: GuestAddress,
         queue_size: u16,
         ttl: u16,
@@ -177,7 +181,7 @@ impl<M: GuestAddressSpace> DescriptorChain<M> {
     }
 
     /// Create a new `DescriptorChain` instance.
-    fn new(mem: M::T, desc_table: GuestAddress, queue_size: u16, head_index: u16) -> Self {
+    fn new(mem: M, desc_table: GuestAddress, queue_size: u16, head_index: u16) -> Self {
         Self::with_ttl(mem, desc_table, queue_size, queue_size, head_index)
     }
 
@@ -188,8 +192,8 @@ impl<M: GuestAddressSpace> DescriptorChain<M> {
 
     /// Return a `GuestMemory` object that can be used to access the buffers
     /// pointed to by the descriptor chain.
-    pub fn memory(&self) -> &M::M {
-        &*self.mem
+    pub fn memory(&self) -> &M::Target {
+        self.mem.deref()
     }
 
     /// Returns an iterator that only yields the readable descriptors in the chain.
@@ -234,7 +238,11 @@ impl<M: GuestAddressSpace> DescriptorChain<M> {
     }
 }
 
-impl<M: GuestAddressSpace> Iterator for DescriptorChain<M> {
+impl<M> Iterator for DescriptorChain<M>
+where
+    M: Deref,
+    M::Target: GuestMemory + Sized,
+{
     type Item = Descriptor;
 
     /// Returns the next descriptor in this descriptor chain, if there is one.
@@ -279,12 +287,16 @@ impl<M: GuestAddressSpace> Iterator for DescriptorChain<M> {
 
 /// An iterator for readable or writable descriptors.
 #[derive(Clone)]
-pub struct DescriptorChainRwIter<M: GuestAddressSpace> {
+pub struct DescriptorChainRwIter<M> {
     chain: DescriptorChain<M>,
     writable: bool,
 }
 
-impl<M: GuestAddressSpace> Iterator for DescriptorChainRwIter<M> {
+impl<M> Iterator for DescriptorChainRwIter<M>
+where
+    M: Deref,
+    M::Target: GuestMemory + Sized,
+{
     type Item = Descriptor;
 
     /// Returns the next descriptor in this descriptor chain, if there is one.
@@ -308,9 +320,9 @@ impl<M: GuestAddressSpace> Iterator for DescriptorChainRwIter<M> {
 
 // We can't derive Debug, because rustc doesn't generate the M::T: Debug
 // constraint
-impl<M: Debug + GuestAddressSpace> Debug for DescriptorChainRwIter<M>
+impl<M> Debug for DescriptorChainRwIter<M>
 where
-    M::T: Debug,
+    M: Debug,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("DescriptorChainRwIter")
@@ -322,16 +334,16 @@ where
 
 /// Consuming iterator over all available descriptor chain heads in the queue.
 #[derive(Debug)]
-pub struct AvailIter<'b, M: GuestAddressSpace> {
-    mem: M::T,
+pub struct AvailIter<'b, M> {
+    mem: M,
     desc_table: GuestAddress,
     avail_ring: GuestAddress,
     last_index: Wrapping<u16>,
     queue_size: u16,
     next_avail: &'b mut Wrapping<u16>,
 }
 
-impl<'b, M: GuestAddressSpace> AvailIter<'b, M> {
+impl<'b, M> AvailIter<'b, M> {
     /// Goes back one position in the available descriptor chain offered by the driver.
     ///
     /// Rust does not support bidirectional iterators. This is the only way to revert the effect
@@ -344,7 +356,11 @@ impl<'b, M: GuestAddressSpace> AvailIter<'b, M> {
     }
 }
 
-impl<'b, M: GuestAddressSpace> Iterator for AvailIter<'b, M> {
+impl<'b, M> Iterator for AvailIter<'b, M>
+where
+    M: Clone + Deref,
+    M::Target: GuestMemory + Sized,
+{
     type Item = DescriptorChain<M>;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -559,7 +575,7 @@ pub struct QueueState<M: GuestAddressSpace> {
 
 impl<M: GuestAddressSpace> QueueState<M> {
     /// Get a consuming iterator over all available descriptor chain heads offered by the driver.
-    pub fn iter(&mut self, mem: M::T) -> Result<AvailIter<'_, M>, Error> {
+    pub fn iter(&mut self, mem: M::T) -> Result<AvailIter<'_, M::T>, Error> {
         self.avail_idx(&mem, Ordering::Acquire)
             .map(move |idx| AvailIter {
                 mem,
@@ -1106,7 +1122,7 @@ impl<M: GuestAddressSpace, S: QueueStateT<M>> Queue<M, S> {
 
 impl<M: GuestAddressSpace> Queue<M, QueueState<M>> {
     /// A consuming iterator over all available descriptor chain heads offered by the driver.
-    pub fn iter(&mut self) -> Result<AvailIter<'_, M>, Error> {
+    pub fn iter(&mut self) -> Result<AvailIter<'_, M::T>, Error> {
         self.state.iter(self.mem.memory())
     }
 }