Add support for virtio device reset

CHANGELOG.md

@@ -28,6 +28,8 @@ and this project adheres to
   rescan the PCI bus after hotplug and remove the device before unplug since no
   automatic notification mechanism is implemented yet. More information can be
   found in the [Device Hotplugging](docs/device-hotplug.md) documentation page.
+- [#5891](https://github.com/firecracker-microvm/firecracker/pull/5891): Added
+  support for virtio device reset.
 - [#5323](https://github.com/firecracker-microvm/firecracker/pull/5323): Add
   support for Vsock Unix domain socket path overriding on snapshot restore. More
   information can be found in the

src/vmm/src/device_manager/mmio.rs

@@ -587,6 +587,12 @@ pub(crate) mod tests {
         fn is_activated(&self) -> bool {
             false
         }
+
+        fn deactivate(&mut self) {}
+
+        fn _reset(&mut self) -> bool {
+            false
+        }
     }
 
     #[test]

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

@@ -979,6 +979,17 @@ impl VirtioDevice for Balloon {
         self.device_state.is_activated()
     }
 
+    fn deactivate(&mut self) {
+        self.device_state = DeviceState::Inactive;
+    }
+
+    fn _reset(&mut self) -> bool {
+        self.stats_timer.arm(Duration::ZERO, None);
+        self.stats_desc_index = None;
+        self.hinting_state = Default::default();
+        true
+    }
+
     fn kick(&mut self) {
         if self.is_activated() {
             if self.free_page_hinting() {

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

@@ -207,6 +207,20 @@ impl VirtioDevice for Block {
         }
     }
 
+    fn deactivate(&mut self) {
+        match self {
+            Self::Virtio(b) => b.deactivate(),
+            Self::VhostUser(b) => b.deactivate(),
+        }
+    }
+
+    fn _reset(&mut self) -> bool {
+        match self {
+            Self::Virtio(b) => b._reset(),
+            Self::VhostUser(b) => b._reset(),
+        }
+    }
+
     fn prepare_save(&mut self) {
         match self {
             Self::Virtio(b) => b.prepare_save(),

src/vmm/src/devices/virtio/block/vhost_user/device.rs

@@ -379,6 +379,14 @@ where
     fn is_activated(&self) -> bool {
         self.device_state.is_activated()
     }
+
+    fn deactivate(&mut self) {
+        self.device_state = DeviceState::Inactive;
+    }
+
+    fn _reset(&mut self) -> bool {
+        false
+    }
 }
 
 #[cfg(test)]

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

@@ -674,6 +674,19 @@ impl VirtioDevice for VirtioBlock {
     fn is_activated(&self) -> bool {
         self.device_state.is_activated()
     }
+
+    fn deactivate(&mut self) {
+        self.device_state = DeviceState::Inactive;
+    }
+
+    fn _reset(&mut self) -> bool {
+        if let Err(err) = self.disk.file_engine.reset() {
+            error!("Failed to reset block IO engine: {:?}", err);
+            return false;
+        }
+        self.is_io_engine_throttled = false;
+        true
+    }
 }
 
 impl Drop for VirtioBlock {

src/vmm/src/devices/virtio/block/virtio/io/async_io.rs

@@ -110,6 +110,13 @@ impl AsyncFileEngine {
         Ok(())
     }
 
+    pub fn reset_ring(&mut self) -> Result<(), AsyncIoError> {
+        let ring = Self::new_ring(&self.file, self.completion_evt.as_raw_fd())
+            .map_err(AsyncIoError::IoUring)?;
+        self.ring = ring;
+        Ok(())
+    }
+
     #[cfg(test)]
     pub fn file(&self) -> &File {
         &self.file

src/vmm/src/devices/virtio/block/virtio/io/mod.rs

@@ -157,6 +157,13 @@ impl FileEngine {
         }
     }
 
+    pub fn reset(&mut self) -> Result<(), BlockIoError> {
+        match self {
+            FileEngine::Async(engine) => engine.reset_ring().map_err(BlockIoError::Async),
+            FileEngine::Sync(_) => Ok(()),
+        }
+    }
+
     pub fn drain(&mut self, discard: bool) -> Result<(), BlockIoError> {
         match self {
             FileEngine::Async(engine) => engine.drain(discard).map_err(BlockIoError::Async),

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

@@ -178,12 +178,27 @@ pub trait VirtioDevice: AsAny + MutEventSubscriber + Send {
     /// Checks if the resources of this device are activated.
     fn is_activated(&self) -> bool;
 
-    /// Optionally deactivates this device and returns ownership of the guest memory map, interrupt
-    /// event, and queue events.
-    fn reset(&mut self) -> Option<(Arc<dyn VirtioInterrupt>, Vec<EventFd>)> {
-        None
+    /// Set the device state to Inactive
+    fn deactivate(&mut self);
+
+    /// Reset the device. Returns true on success, false otherwise.
+    /// It must not be overridden.
+    fn reset(&mut self) -> bool {
+        if !self._reset() {
+            return false;
+        }
+        self.deactivate();
+        self.set_acked_features(0);
+        for queue in self.queues_mut() {
+            *queue = Queue::new(queue.max_size);
+        }
+        true
     }
 
+    /// Backend-specific reset logic. Returns true on success, false if the
+    /// backend does not support reset.
+    fn _reset(&mut self) -> bool;
+
     /// Mark pages used by queues as dirty.
     fn mark_queue_memory_dirty(&mut self, mem: &GuestMemoryMmap) -> Result<(), QueueError> {
         for queue in self.queues_mut() {
@@ -310,6 +325,14 @@ pub(crate) mod tests {
         fn is_activated(&self) -> bool {
             todo!()
         }
+
+        fn deactivate(&mut self) {
+            todo!()
+        }
+
+        fn _reset(&mut self) -> bool {
+            todo!()
+        }
     }
 
     #[test]

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

@@ -656,6 +656,21 @@ impl VirtioDevice for VirtioMem {
         self.device_state.is_activated()
     }
 
+    fn deactivate(&mut self) {
+        self.device_state = DeviceState::Inactive;
+    }
+
+    fn _reset(&mut self) -> bool {
+        // Virtio spec, section 5.15.5.2:
+        // The device MUST NOT change the state of memory blocks during device
+        // reset. The device MUST NOT modify memory or memory properties of
+        // plugged memory blocks during device reset.
+        //
+        // Note: the Linux virtio-mem driver does not support rebinding when
+        // memory is plugged
+        true
+    }
+
     fn activate(
         &mut self,
         mem: GuestMemoryMmap,

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

@@ -135,6 +135,15 @@ impl RxBuffers {
         })
     }
 
+    /// Reset the RX buffers to their initial state.
+    fn clear(&mut self) {
+        self.iovec.clear();
+        self.parsed_descriptors.clear();
+        self.used_descriptors = 0;
+        self.used_bytes = 0;
+        self.min_buffer_size = 0;
+    }
+
     /// Add a new `DescriptorChain` that we received from the RX queue in the buffer.
     ///
     /// SAFETY: The `DescriptorChain` cannot be referencing the same memory location as any other
@@ -1088,6 +1097,16 @@ impl VirtioDevice for Net {
         self.device_state.is_activated()
     }
 
+    fn deactivate(&mut self) {
+        self.device_state = DeviceState::Inactive;
+    }
+
+    fn _reset(&mut self) -> bool {
+        self.rx_buffer.clear();
+        self.tx_buffer.clear();
+        true
+    }
+
     /// Prepare saving state
     fn prepare_save(&mut self) {
         // We shouldn't be messing with the queue if the device is not activated.
@@ -2601,4 +2620,16 @@ pub mod tests {
         assert!(queues[RX_INDEX].uses_notif_suppression);
         assert!(queues[TX_INDEX].uses_notif_suppression);
     }
+
+    #[test]
+    fn test_reset() {
+        let mem = single_region_mem(2 * MAX_BUFFER_SIZE);
+        let mut th = TestHelper::get_default(&mem);
+        th.activate_net();
+
+        assert!(th.net().is_activated());
+        assert!(th.net().reset());
+        assert!(!th.net().is_activated());
+        assert_eq!(th.net().acked_features(), 0);
+    }
 }

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

@@ -588,6 +588,14 @@ impl VirtioDevice for Pmem {
         self.device_state.is_activated()
     }
 
+    fn deactivate(&mut self) {
+        self.device_state = DeviceState::Inactive;
+    }
+
+    fn _reset(&mut self) -> bool {
+        true
+    }
+
     fn kick(&mut self) {
         if self.is_activated() {
             info!("kick pmem {}.", self.config.id);

src/vmm/src/devices/virtio/queue.rs

@@ -683,19 +683,6 @@ impl Queue {
 
         new - used_event - Wrapping(1) < new - old
     }
-
-    /// Resets the Virtio Queue
-    pub(crate) fn reset(&mut self) {
-        self.ready = false;
-        self.size = self.max_size;
-        self.desc_table_address = GuestAddress(0);
-        self.avail_ring_address = GuestAddress(0);
-        self.used_ring_address = GuestAddress(0);
-        self.next_avail = Wrapping(0);
-        self.next_used = Wrapping(0);
-        self.num_added = Wrapping(0);
-        self.uses_notif_suppression = false;
-    }
 }
 
 #[cfg(kani)]

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

@@ -307,6 +307,14 @@ impl VirtioDevice for Entropy {
         self.device_state.is_activated()
     }
 
+    fn deactivate(&mut self) {
+        self.device_state = DeviceState::Inactive;
+    }
+
+    fn _reset(&mut self) -> bool {
+        true
+    }
+
     fn activate(
         &mut self,
         mem: GuestMemoryMmap,