introduce QueueSync

Similar to Queue, QueueSync associates a GuestAddressSpace to a
QueueState.  The QueueState however is wrapped with reference
counting and with a mutex.  All access to the QueueSync object
has to go through a QueueGuard, which takes care of locking the
mutex.

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

Author: bonzini

crates/virtio-queue/src/generic.rs

@@ -5,8 +5,9 @@
 use std::num::Wrapping;
 use std::ops::DerefMut;
 
-use crate::{Error, Queue, QueueGuard, QueueState};
+use crate::{Error, Queue, QueueGuard, QueueState, QueueSync};
 use std::sync::atomic::Ordering;
+use std::sync::{Arc, Mutex, MutexGuard};
 use vm_memory::GuestAddressSpace;
 
 /// Lifetime-generic guard associated to a QueueStateT. In practice,
@@ -167,3 +168,32 @@ impl<M: GuestAddressSpace> QueueT<M> for Queue<M> {
         f(self.acquire())
     }
 }
+
+impl<'g, M: GuestAddressSpace> QueueStateGuard<'g> for QueueSync<M> {
+    type Out = MutexGuard<'g, QueueState>;
+}
+
+impl<M: GuestAddressSpace> QueueT<M> for QueueSync<M> {
+    type Guard = Self;
+
+    fn construct(mem: M, state: QueueState) -> Self {
+        QueueSync {
+            mem,
+            state: Arc::new(Mutex::new(state)),
+        }
+    }
+    fn with<
+        'a,
+        'g,
+        U,
+        F: FnOnce(QueueGuard<M::T, <Self::Guard as QueueStateGuard<'g>>::Out>) -> U,
+    >(
+        &'a mut self,
+        f: F,
+    ) -> U
+    where
+        'a: 'g,
+    {
+        f(self.lock())
+    }
+}

crates/virtio-queue/src/lib.rs

@@ -28,6 +28,7 @@ use std::mem::size_of;
 use std::num::Wrapping;
 use std::ops::{Deref, DerefMut};
 use std::sync::atomic::{fence, Ordering};
+use std::sync::{Arc, Mutex, MutexGuard};
 
 use log::error;
 use vm_memory::{
@@ -1030,6 +1031,33 @@ impl<M: GuestAddressSpace> Queue<M> {
     }
 }
 
+/// A convenient wrapper struct for a thread-safe virtio queue, with associated GuestMemory object.
+#[derive(Clone, Debug)]
+pub struct QueueSync<M: GuestAddressSpace> {
+    /// Guest memory object associated with the queue.
+    pub mem: M,
+    /// Virtio queue state.
+    pub state: Arc<Mutex<QueueState>>,
+}
+
+impl<M: GuestAddressSpace> QueueSync<M> {
+    /// Construct an empty virtio queue with the given `max_size`.
+    pub fn new(mem: M, max_size: u16) -> Self {
+        QueueSync {
+            mem,
+            state: Arc::new(Mutex::new(QueueState::new(max_size))),
+        }
+    }
+
+    /// Get an exclusive reference to the underlying `QueueState` object.
+    ///
+    /// 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(&self) -> QueueGuard<M::T, MutexGuard<QueueState>> {
+        QueueGuard::new(self.mem.memory(), self.state.lock().unwrap())
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;