test(vhost-user-blk): preparation for unit testsing

Made `VhostUserBlock` generic on `VhostUserHandleBackend`.
This will allow us to write unit tests.

Signed-off-by: Egor Lazarchuk <[email protected]>

Author: ShadowCurse

src/vmm/src/devices/virtio/vhost_user_block/device.rs

@@ -13,7 +13,7 @@ use log::error;
 use utils::eventfd::EventFd;
 use utils::u64_to_usize;
 use vhost::vhost_user::message::*;
-use vhost::vhost_user::VhostUserMaster;
+use vhost::vhost_user::Master;
 
 use super::{VhostUserBlockError, NUM_QUEUES, QUEUE_SIZE};
 use crate::devices::virtio::block_common::CacheType;
@@ -23,7 +23,8 @@ use crate::devices::virtio::gen::virtio_blk::{
 };
 use crate::devices::virtio::gen::virtio_ring::VIRTIO_RING_F_EVENT_IDX;
 use crate::devices::virtio::queue::Queue;
-use crate::devices::virtio::vhost_user::VhostUserHandle;
+use crate::devices::virtio::vhost_user::VhostUserHandleBackend;
+use crate::devices::virtio::vhost_user::VhostUserHandleImpl;
 use crate::devices::virtio::{ActivateError, TYPE_BLOCK};
 use crate::logger::{IncMetric, METRICS};
 use crate::vmm_config::drive::BlockDeviceConfig;
@@ -93,9 +94,10 @@ impl From<VhostUserBlockConfig> for BlockDeviceConfig {
     }
 }
 
+pub type VhostUserBlock = VhostUserBlockImpl<Master>;
+
 /// vhost-user block device.
-#[derive(Debug)]
-pub struct VhostUserBlock {
+pub struct VhostUserBlockImpl<T: VhostUserHandleBackend> {
     // Virtio fields.
     pub avail_features: u64,
     pub acked_features: u64,
@@ -116,11 +118,37 @@ pub struct VhostUserBlock {
     pub read_only: bool,
 
     // Vhost user protocol handle
-    pub vu_handle: VhostUserHandle,
+    pub vu_handle: VhostUserHandleImpl<T>,
     pub vu_acked_protocol_features: u64,
 }
 
-impl VhostUserBlock {
+// Need custom implementation because otherwise `Debug` is required for `vhost::Master`
+impl<T: VhostUserHandleBackend> std::fmt::Debug for VhostUserBlockImpl<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("VhostUserBlockImpl")
+            .field("avail_features", &self.avail_features)
+            .field("acked_features", &self.acked_features)
+            .field("config_space", &self.config_space)
+            .field("activate_evt", &self.activate_evt)
+            .field("queues", &self.queues)
+            .field("queue_evts", &self.queue_evts)
+            .field("device_state", &self.device_state)
+            .field("irq_trigger", &self.irq_trigger)
+            .field("id", &self.id)
+            .field("partuuid", &self.partuuid)
+            .field("cache_type", &self.cache_type)
+            .field("root_device", &self.root_device)
+            .field("read_only", &self.read_only)
+            .field("vu_handle", &self.vu_handle)
+            .field(
+                "vu_acked_protocol_features",
+                &self.vu_acked_protocol_features,
+            )
+            .finish()
+    }
+}
+
+impl<T: VhostUserHandleBackend> VhostUserBlockImpl<T> {
     pub fn new(config: VhostUserBlockConfig) -> Result<Self, VhostUserBlockError> {
         let mut requested_features = (1 << VIRTIO_F_VERSION_1)
             | (1 << VIRTIO_RING_F_EVENT_IDX)
@@ -137,7 +165,7 @@ impl VhostUserBlock {
 
         let requested_protocol_features = VhostUserProtocolFeatures::CONFIG;
 
-        let mut vu_handle = VhostUserHandle::new(&config.socket, NUM_QUEUES)
+        let mut vu_handle = VhostUserHandleImpl::<T>::new(&config.socket, NUM_QUEUES)
             .map_err(VhostUserBlockError::VhostUser)?;
         let (acked_features, acked_protocol_features) = vu_handle
             .negotiate_features(requested_features, requested_protocol_features)