vhost: promote get/set_status from vdpa to vhost

Although originally introduced for VDPA we also have support for
get/set status messages for vhost-user. So lets promote the trait
functions to the main VhostBackend traits while providing a default
implementation which responds for errors (which the Kernel variant
would inherit).

As the status bits are common between backends most of the
implementation details can be handled within the vhost-user traits.

Signed-off-by: Alex Bennée <[email protected]>

---
v2
  - also add impls for DummySlaveReqHandler
  - move VhostVdpa impls to impl<T: VhostKernBackend> VhostBackend for T

Author: stsquad

crates/vhost-user-backend/src/handler.rs

@@ -88,6 +88,8 @@ pub struct VhostUserHandler<S, V, B: Bitmap + 'static> {
     atomic_mem: GM<B>,
     vrings: Vec<V>,
     worker_threads: Vec<thread::JoinHandle<VringEpollResult<()>>>,
+    /// VirtIO Device Status field, when using get/set status
+    status: u8,
 }
 
 // Ensure VhostUserHandler: Clone + Send + Sync + 'static.
@@ -147,6 +149,7 @@ where
             atomic_mem,
             vrings,
             worker_threads,
+            status: 0,
         })
     }
 }
@@ -586,6 +589,15 @@ where
 
         Ok(())
     }
+
+    fn get_status(&self) -> VhostUserResult<u8> {
+        Ok(self.status)
+    }
+
+    fn set_status(&mut self, status: u8) -> VhostUserResult<()> {
+        self.status = status;
+        Ok(())
+    }
 }
 
 impl<S, V, B: Bitmap> Drop for VhostUserHandler<S, V, B> {

crates/vhost/src/backend.rs

@@ -308,6 +308,30 @@ pub trait VhostBackend: std::marker::Sized {
     /// * `queue_index` - Index of the queue to modify.
     /// * `fd` - EventFd that will be signaled from guest.
     fn set_vring_err(&self, queue_index: usize, fd: &EventFd) -> Result<()>;
+
+    /// Set the status.
+    /// The status bits follow the same definition of the device
+    /// status defined in virtio-spec.
+    ///
+    /// As not all backends can implement this we provide a default
+    /// implementation that returns an Error.
+    ///
+    /// # Arguments
+    /// * `status` - Status bits to set
+    fn set_status(&self, _status: u8) -> Result<()> {
+        Err(Error::InvalidOperation)
+    }
+
+    /// Get the status.
+    ///
+    /// The status bits follow the same definition of the device
+    /// status defined in virtio-spec.
+    ///
+    /// As not all backends can implement this we provide a default
+    /// implementation that returns an Error.
+    fn get_status(&self) -> Result<u8> {
+        Err(Error::InvalidOperation)
+    }
 }
 
 /// An interface for setting up vhost-based backend drivers.
@@ -394,6 +418,17 @@ pub trait VhostBackendMut: std::marker::Sized {
     /// * `queue_index` - Index of the queue to modify.
     /// * `fd` - EventFd that will be signaled from guest.
     fn set_vring_err(&mut self, queue_index: usize, fd: &EventFd) -> Result<()>;
+
+    /// Set the status.
+    /// The status bits follow the same definition of the device status defined in virtio-spec.
+    ///
+    /// # Arguments
+    /// * `status` - Status bits to set
+    fn set_status(&mut self, status: u8) -> Result<()>;
+
+    /// Get the status.
+    /// The status bits follow the same definition of the device status defined in virtio-spec.
+    fn get_status(&self) -> Result<u8>;
 }
 
 impl<T: VhostBackendMut> VhostBackend for RwLock<T> {
@@ -454,6 +489,14 @@ impl<T: VhostBackendMut> VhostBackend for RwLock<T> {
     fn set_vring_err(&self, queue_index: usize, fd: &EventFd) -> Result<()> {
         self.write().unwrap().set_vring_err(queue_index, fd)
     }
+
+    fn set_status(&self, status: u8) -> Result<()> {
+        self.write().unwrap().set_status(status)
+    }
+
+    fn get_status(&self) -> Result<u8> {
+        self.write().unwrap().get_status()
+    }
 }
 
 impl<T: VhostBackendMut> VhostBackend for RefCell<T> {
@@ -512,6 +555,14 @@ impl<T: VhostBackendMut> VhostBackend for RefCell<T> {
     fn set_vring_err(&self, queue_index: usize, fd: &EventFd) -> Result<()> {
         self.borrow_mut().set_vring_err(queue_index, fd)
     }
+
+    fn set_status(&self, status: u8) -> Result<()> {
+        self.borrow_mut().set_status(status)
+    }
+
+    fn get_status(&self) -> Result<u8> {
+        self.borrow_mut().get_status()
+    }
 }
 
 #[cfg(any(test, feature = "test-utils"))]
@@ -543,7 +594,9 @@ impl VhostUserMemoryRegionInfo {
 mod tests {
     use super::*;
 
-    struct MockBackend {}
+    struct MockBackend {
+        status: u8,
+    }
 
     impl VhostBackendMut for MockBackend {
         fn get_features(&mut self) -> Result<u64> {
@@ -625,11 +678,20 @@ mod tests {
             assert_eq!(queue_index, 1);
             Ok(())
         }
+
+        fn set_status(&mut self, status: u8) -> Result<()> {
+            self.status = status;
+            Ok(())
+        }
+
+        fn get_status(&self) -> Result<u8> {
+            Ok(self.status)
+        }
     }
 
     #[test]
     fn test_vring_backend_mut() {
-        let b = RwLock::new(MockBackend {});
+        let b = RwLock::new(MockBackend { status: 0 });
 
         assert_eq!(b.get_features().unwrap(), 0x1);
         b.set_features(0x1).unwrap();

crates/vhost/src/vdpa.rs

@@ -33,17 +33,6 @@ pub trait VhostVdpa: VhostBackend {
     /// The device ids follow the same definition of the device id defined in virtio-spec.
     fn get_device_id(&self) -> Result<u32>;
 
-    /// Get the status.
-    /// The status bits follow the same definition of the device status defined in virtio-spec.
-    fn get_status(&self) -> Result<u8>;
-
-    /// Set the status.
-    /// The status bits follow the same definition of the device status defined in virtio-spec.
-    ///
-    /// # Arguments
-    /// * `status` - Status bits to set
-    fn set_status(&self, status: u8) -> Result<()>;
-
     /// Get the device configuration.
     ///
     /// # Arguments

crates/vhost/src/vhost_kern/mod.rs

@@ -291,6 +291,22 @@ impl<T: VhostKernBackend> VhostBackend for T {
         let ret = unsafe { ioctl_with_ref(self, VHOST_SET_VRING_ERR(), &vring_file) };
         ioctl_result(ret, ())
     }
+
+    fn get_status(&self) -> Result<u8> {
+        let mut status: u8 = 0;
+
+        // SAFETY: This ioctl is called on a valid vhost-vdpa fd and has its
+        // return value checked.
+        let ret = unsafe { ioctl_with_mut_ref(self, VHOST_VDPA_GET_STATUS(), &mut status) };
+        ioctl_result(ret, status)
+    }
+
+    fn set_status(&self, status: u8) -> Result<()> {
+        // SAFETY: This ioctl is called on a valid vhost-vdpa fd and has its
+        // return value checked.
+        let ret = unsafe { ioctl_with_ref(self, VHOST_VDPA_SET_STATUS(), &status) };
+        ioctl_result(ret, ())
+    }
 }
 
 /// Interface to handle in-kernel backend features.

crates/vhost/src/vhost_kern/vdpa.rs

@@ -101,22 +101,6 @@ impl<AS: GuestAddressSpace> VhostVdpa for VhostKernVdpa<AS> {
         ioctl_result(ret, device_id)
     }
 
-    fn get_status(&self) -> Result<u8> {
-        let mut status: u8 = 0;
-
-        // SAFETY: This ioctl is called on a valid vhost-vdpa fd and has its
-        // return value checked.
-        let ret = unsafe { ioctl_with_mut_ref(self, VHOST_VDPA_GET_STATUS(), &mut status) };
-        ioctl_result(ret, status)
-    }
-
-    fn set_status(&self, status: u8) -> Result<()> {
-        // SAFETY: This ioctl is called on a valid vhost-vdpa fd and has its
-        // return value checked.
-        let ret = unsafe { ioctl_with_ref(self, VHOST_VDPA_SET_STATUS(), &status) };
-        ioctl_result(ret, ())
-    }
-
     fn get_config(&self, offset: u32, buffer: &mut [u8]) -> Result<()> {
         let mut config = VhostVdpaConfig::new(buffer.len())
             .map_err(|_| Error::IoctlError(IOError::from_raw_os_error(libc::ENOMEM)))?;

crates/vhost/src/vhost_user/dummy_slave.rs

@@ -17,6 +17,7 @@ pub struct DummySlaveReqHandler {
     pub features_acked: bool,
     pub acked_features: u64,
     pub acked_protocol_features: u64,
+    pub status: u8,
     pub queue_num: usize,
     pub vring_num: [u32; MAX_QUEUE_NUM],
     pub vring_base: [u32; MAX_QUEUE_NUM],
@@ -291,4 +292,13 @@ impl VhostUserSlaveReqHandlerMut for DummySlaveReqHandler {
     fn remove_mem_region(&mut self, _region: &VhostUserSingleMemoryRegion) -> Result<()> {
         Ok(())
     }
+
+    fn get_status(&self) -> Result<u8> {
+        Ok(self.status)
+    }
+
+    fn set_status(&mut self, status: u8) -> Result<()> {
+        self.status = status;
+        Ok(())
+    }
 }

crates/vhost/src/vhost_user/master.rs

@@ -3,6 +3,7 @@
 
 //! Traits and Struct for vhost-user master.
 
+use std::convert::TryFrom;
 use std::fs::File;
 use std::mem;
 use std::os::unix::io::{AsRawFd, RawFd};
@@ -330,6 +331,26 @@ impl VhostBackend for Master {
         let hdr = node.send_fd_for_vring(MasterReq::SET_VRING_ERR, queue_index, fd.as_raw_fd())?;
         node.wait_for_ack(&hdr).map_err(|e| e.into())
     }
+
+    /// Set the status at the remote end (if supported)
+    fn set_status(&self, status: u8) -> Result<()> {
+        let mut node = self.node();
+        // depends on VhostUserProtocolFeatures::STATUS
+        node.check_proto_feature(VhostUserProtocolFeatures::STATUS)?;
+        let val = VhostUserU64::new(status.into());
+        node.send_request_with_body(MasterReq::SET_STATUS, &val, None)?;
+        Ok(())
+    }
+
+    /// Get the status from the remote end (if supported)
+    fn get_status(&self) -> Result<u8> {
+        let mut node = self.node();
+        // depends on VhostUserProtocolFeatures::STATUS
+        node.check_proto_feature(VhostUserProtocolFeatures::STATUS)?;
+        let hdr = node.send_request_header(MasterReq::GET_STATUS, None)?;
+        let reply = node.recv_reply::<VhostUserU64>(&hdr)?;
+        u8::try_from(reply.value).or(error_code(VhostUserError::InvalidParam))
+    }
 }
 
 impl VhostUserMaster for Master {

crates/vhost/src/vhost_user/slave_req_handler.rs

@@ -1,6 +1,7 @@
 // Copyright (C) 2019 Alibaba Cloud Computing. All rights reserved.
 // SPDX-License-Identifier: Apache-2.0
 
+use std::convert::TryFrom;
 use std::fs::File;
 use std::mem;
 use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
@@ -70,6 +71,8 @@ pub trait VhostUserSlaveReqHandler {
     fn get_max_mem_slots(&self) -> Result<u64>;
     fn add_mem_region(&self, region: &VhostUserSingleMemoryRegion, fd: File) -> Result<()>;
     fn remove_mem_region(&self, region: &VhostUserSingleMemoryRegion) -> Result<()>;
+    fn get_status(&self) -> Result<u8>;
+    fn set_status(&self, status: u8) -> Result<()>;
 }
 
 /// Services provided to the master by the slave without interior mutability.
@@ -118,6 +121,8 @@ pub trait VhostUserSlaveReqHandlerMut {
     fn get_max_mem_slots(&mut self) -> Result<u64>;
     fn add_mem_region(&mut self, region: &VhostUserSingleMemoryRegion, fd: File) -> Result<()>;
     fn remove_mem_region(&mut self, region: &VhostUserSingleMemoryRegion) -> Result<()>;
+    fn get_status(&self) -> Result<u8>;
+    fn set_status(&mut self, status: u8) -> Result<()>;
 }
 
 impl<T: VhostUserSlaveReqHandlerMut> VhostUserSlaveReqHandler for Mutex<T> {
@@ -226,6 +231,14 @@ impl<T: VhostUserSlaveReqHandlerMut> VhostUserSlaveReqHandler for Mutex<T> {
     fn remove_mem_region(&self, region: &VhostUserSingleMemoryRegion) -> Result<()> {
         self.lock().unwrap().remove_mem_region(region)
     }
+
+    fn get_status(&self) -> Result<u8> {
+        self.lock().unwrap().get_status()
+    }
+
+    fn set_status(&self, status: u8) -> Result<()> {
+        self.lock().unwrap().set_status(status)
+    }
 }
 
 /// Server to handle service requests from masters from the master communication channel.
@@ -519,6 +532,19 @@ impl<S: VhostUserSlaveReqHandler> SlaveReqHandler<S> {
                 let res = self.backend.remove_mem_region(&msg);
                 self.send_ack_message(&hdr, res)?;
             }
+            Ok(MasterReq::SET_STATUS) => {
+                self.check_proto_feature(VhostUserProtocolFeatures::STATUS)?;
+                self.check_request_size(&hdr, size, hdr.get_size() as usize)?;
+                let msg = self.extract_request_body::<VhostUserU64>(&hdr, size, &buf)?;
+                let status = u8::try_from(msg.value).or(Err(Error::InvalidParam))?;
+                self.backend.set_status(status)?;
+            }
+            Ok(MasterReq::GET_STATUS) => {
+                self.check_proto_feature(VhostUserProtocolFeatures::STATUS)?;
+                let num = self.backend.get_status()?;
+                let msg = VhostUserU64::new(num.into());
+                self.send_reply_message(&hdr, &msg)?;
+            }
             _ => {
                 return Err(Error::InvalidMessage);
             }