allow iter() on Queue<_, QueueStateSync>

Create a guard type for a locked Queue instead of just reusing the guard of the
underlying QueueState.  The guard can have a single-argument iter() method,
just like Queue<_, QueueState> has.

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>

Author: bonzini

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

@@ -332,8 +332,7 @@ mod tests {
             .unwrap();
 
         let mut q: Queue<_, QueueState> = vq.as_queue(mem);
-        q
-            .iter()
+        q.iter()
             .unwrap()
             .next()
             .expect("failed to build desc chain")

crates/virtio-queue/src/lib.rs

@@ -1013,6 +1013,35 @@ pub struct Queue<M: GuestAddressSpace, S: QueueStateT = QueueState> {
     pub state: S,
 }
 
+/// A struct that holds an exclusive reference to a `QueueState` object, that was
+/// obtained from a `Queue`.  As such it remembers the associated GuestMemory object
+/// and can use it to return an iterator.
+pub struct QueueGuard<M: GuestAddressSpace, G: DerefMut<Target = QueueState>> {
+    mem: M::T,
+    guard: G,
+}
+
+impl<M: GuestAddressSpace, G: DerefMut<Target = QueueState>> Deref for QueueGuard<M, G> {
+    type Target = QueueState;
+
+    fn deref(&self) -> &Self::Target {
+        self.guard.deref()
+    }
+}
+
+impl<M: GuestAddressSpace, G: DerefMut<Target = QueueState>> DerefMut for QueueGuard<M, G> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.guard.deref_mut()
+    }
+}
+
+impl<M: GuestAddressSpace, G: DerefMut<Target = QueueState>> QueueGuard<M, G> {
+    /// A consuming iterator over all available descriptor chain heads offered by the driver.
+    pub fn iter(&mut self) -> Result<AvailIter<'_, M::T>, Error> {
+        self.guard.iter(self.mem.clone())
+    }
+}
+
 impl<M: GuestAddressSpace, S: QueueStateT> Queue<M, S> {
     /// Construct an empty virtio queue with the given `max_size`.
     pub fn new(mem: M, max_size: u16) -> Self {
@@ -1036,8 +1065,11 @@ impl<M: GuestAddressSpace, S: QueueStateT> Queue<M, S> {
     ///
     /// Logically this method will acquire the underlying lock protecting the `QueueState` Object.
     /// The lock will be released when the returned object gets dropped.
-    pub fn lock(&mut self) -> <S::Guard as QueueStateGuard>::Out {
-        self.state.lock()
+    pub fn lock(&mut self) -> QueueGuard<M, <S::Guard as QueueStateGuard>::Out> {
+        QueueGuard {
+            mem: self.mem.memory(),
+            guard: self.state.lock(),
+        }
     }
 
     /// Get the maximum size of the virtio queue.