queue: add QueueStateSync for multi-threading

Introduce QueueStateSync, which is essentially Arc<Mutex<QueueState>>,
for multi-threaded context. The QueueStateSync object could be cloned
and sent to different threads for concurrently processing available
descriptors.

Signed-off-by: Liu Jiang <gerry@linux.alibaba.com>

Author: jiangliu

crates/virtio-queue/src/lib.rs

@@ -6,7 +6,7 @@
 //
 // Copyright © 2019 Intel Corporation
 //
-// Copyright (C) 2020 Alibaba Cloud. All rights reserved.
+// Copyright (C) 2020-2021 Alibaba Cloud. All rights reserved.
 //
 // SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
 
@@ -26,7 +26,7 @@ use std::mem::size_of;
 use std::num::Wrapping;
 use std::ops::{Deref, DerefMut};
 use std::sync::atomic::{fence, Ordering};
-use std::sync::MutexGuard;
+use std::sync::{Arc, Mutex, MutexGuard};
 
 use defs::{
     VIRTQ_AVAIL_ELEMENT_SIZE, VIRTQ_AVAIL_RING_HEADER_SIZE, VIRTQ_AVAIL_RING_META_SIZE,
@@ -849,6 +849,97 @@ impl<M: GuestAddressSpace> QueueStateT<M> for QueueState<M> {
     }
 }
 
+/// Struct to maintain information and manipulate state of a virtio queue for multi-threaded
+/// context.
+#[derive(Clone, Debug)]
+pub struct QueueStateSync<M: GuestAddressSpace> {
+    state: Arc<Mutex<QueueState<M>>>,
+}
+
+impl<M: GuestAddressSpace> QueueStateT<M> for QueueStateSync<M> {
+    fn new(max_size: u16) -> Self {
+        QueueStateSync {
+            state: Arc::new(Mutex::new(QueueState::new(max_size))),
+        }
+    }
+
+    fn lock(&mut self) -> QueueStateGuard<'_, M> {
+        QueueStateGuard::MutexGuard(self.state.lock().unwrap())
+    }
+
+    fn max_size(&self) -> u16 {
+        self.state.lock().unwrap().max_size()
+    }
+
+    fn actual_size(&self) -> u16 {
+        self.state.lock().unwrap().actual_size()
+    }
+
+    fn set_size(&mut self, size: u16) {
+        self.state.lock().unwrap().set_size(size)
+    }
+
+    fn ready(&self) -> bool {
+        self.state.lock().unwrap().ready
+    }
+
+    fn set_ready(&mut self, ready: bool) {
+        self.state.lock().unwrap().set_ready(ready)
+    }
+
+    fn set_desc_table_address(&mut self, low: Option<u32>, high: Option<u32>) {
+        self.state.lock().unwrap().set_desc_table_address(low, high);
+    }
+
+    fn set_avail_ring_address(&mut self, low: Option<u32>, high: Option<u32>) {
+        self.state.lock().unwrap().set_avail_ring_address(low, high);
+    }
+
+    fn set_used_ring_address(&mut self, low: Option<u32>, high: Option<u32>) {
+        self.state.lock().unwrap().set_used_ring_address(low, high);
+    }
+
+    fn reset(&mut self) {
+        self.state.lock().unwrap().reset();
+    }
+
+    fn set_event_idx(&mut self, enabled: bool) {
+        self.state.lock().unwrap().set_event_idx(enabled);
+    }
+
+    fn is_valid(&self, mem: &M::T) -> bool {
+        self.state.lock().unwrap().is_valid(mem)
+    }
+
+    fn avail_idx(&self, mem: &M::T, order: Ordering) -> Result<Wrapping<u16>, Error> {
+        self.state.lock().unwrap().avail_idx(mem, order)
+    }
+
+    fn add_used(&mut self, mem: &M::T, head_index: u16, len: u32) -> Result<(), Error> {
+        self.state.lock().unwrap().add_used(mem, head_index, len)
+    }
+
+    fn enable_notification(&mut self, mem: &M::T) -> Result<bool, Error> {
+        self.state.lock().unwrap().enable_notification(mem)
+    }
+
+    fn disable_notification(&mut self, mem: &M::T) -> Result<(), Error> {
+        self.state.lock().unwrap().disable_notification(mem)
+    }
+
+    fn needs_notification(&mut self, mem: &M::T) -> Result<bool, Error> {
+        self.state.lock().unwrap().needs_notification(mem)
+    }
+
+    fn next_avail(&self) -> u16 {
+        self.state.lock().unwrap().next_avail()
+    }
+
+    fn set_next_avail(&mut self, next_avail: u16) {
+        self.state.lock().unwrap().set_next_avail(next_avail);
+    }
+}
+
 /// A convenient wrapper struct for a virtio queue, with associated GuestMemory object.
 #[derive(Clone, Debug)]
 pub struct Queue<M: GuestAddressSpace, S: QueueStateT<M> = QueueState<M>> {