Add support for virtio device reset

CHANGELOG.md

@@ -10,6 +10,8 @@ and this project adheres to
 
 ### Added
 
+- [#5891](https://github.com/firecracker-microvm/firecracker/pull/5891): Added
+  support for virtio device reset.
 - [#5983](https://github.com/firecracker-microvm/firecracker/pull/5983): Add two
   optional metrics fields, set via `PUT /metrics` or a config file: `emit_id`
   emits the microVM instance id under a top-level `id` field, and `properties`

resources/seccomp/aarch64-unknown-linux-musl.json

@@ -1029,6 +1029,18 @@
             {
                 "syscall": "close"
             },
+            {
+                "syscall": "eventfd2",
+                "comment": "Needed for recreating the MSI-X vector eventfds when a PCI device is reset by the guest (MsixVectorGroup recreated from the vCPU thread)"
+            },
+            {
+                "syscall": "io_uring_enter",
+                "comment": "Needed to drain the async block IO engine's io_uring when the device is reset by the guest (from the vCPU thread)"
+            },
+            {
+                "syscall": "epoll_ctl",
+                "comment": "Needed to remove the vsock muxer's connection and listener epoll listeners when the device is reset by the guest (from the vCPU thread)"
+            },
             {
                 "syscall": "fstat",
                 "comment": "Used for reading the local timezone from /etc/localtime"

resources/seccomp/x86_64-unknown-linux-musl.json

@@ -1041,6 +1041,18 @@
             {
                 "syscall": "close"
             },
+            {
+                "syscall": "eventfd2",
+                "comment": "Needed for recreating the MSI-X vector eventfds when a PCI device is reset by the guest (MsixVectorGroup recreated from the vCPU thread)"
+            },
+            {
+                "syscall": "io_uring_enter",
+                "comment": "Needed to drain the async block IO engine's io_uring when the device is reset by the guest (from the vCPU thread)"
+            },
+            {
+                "syscall": "epoll_ctl",
+                "comment": "Needed to remove the vsock muxer's connection and listener epoll listeners when the device is reset by the guest (from the vCPU thread)"
+            },
             {
                 "syscall": "fstat",
                 "comment": "Used for reading the local timezone from /etc/localtime"

src/vmm/src/device_manager/mmio.rs

@@ -592,6 +592,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

@@ -976,6 +976,20 @@ impl VirtioDevice for Balloon {
         self.device_state.is_activated()
     }
 
+    fn deactivate(&mut self) {
+        self.device_state = DeviceState::Inactive;
+    }
+
+    fn _reset(&mut self) -> bool {
+        self.config_space.actual_pages = 0;
+        self.config_space.free_page_hint_cmd_id = FREE_PAGE_HINT_STOP;
+        self.stats_timer.arm(Duration::ZERO, None);
+        self.stats_desc_index = None;
+        self.latest_stats = BalloonStats::default();
+        self.hinting_state = Default::default();
+        true
+    }
+
     fn kick(&mut self) {
         if self.is_activated() {
             if self.free_page_hinting() {

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

@@ -143,6 +143,7 @@ impl MutEventSubscriber for Balloon {
                 "Balloon: The device is not yet activated. Spurious event received: {:?}",
                 source
             );
+            self.drain_queue_events();
         }
     }
 

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

@@ -375,6 +375,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

@@ -670,6 +670,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.drain(true) {
+            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/event_handler.rs

@@ -95,6 +95,18 @@ impl MutEventSubscriber for VirtioBlock {
                 "Block: The device is not yet activated. Spurious event received: {:?}",
                 source
             );
+            match source {
+                Self::PROCESS_QUEUE => self.drain_queue_events(),
+                Self::PROCESS_RATE_LIMITER => {
+                    self.rate_limiter.event_handler();
+                }
+                Self::PROCESS_ASYNC_COMPLETION => {
+                    if let FileEngine::Async(ref engine) = self.disk.file_engine {
+                        engine.completion_evt().read();
+                    }
+                }
+                _ => (),
+            }
         }
     }
 

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

@@ -194,12 +194,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() {
@@ -224,6 +239,15 @@ pub trait VirtioDevice: AsAny + MutEventSubscriber + Send {
         }
     }
 
+    /// Drain all queue notification eventfds, discarding any pending
+    /// notifications. This is used if a notification arrives while a device
+    /// is being reset and before it's activated again.
+    fn drain_queue_events(&self) {
+        for event in self.queue_events() {
+            event.read();
+        }
+    }
+
     /// Kick the device, as if it had received external events.
     fn kick(&mut self) {
         if self.is_activated() {
@@ -327,6 +351,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

@@ -649,6 +649,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/mem/event_handler.rs

@@ -76,6 +76,7 @@ impl MutEventSubscriber for VirtioMem {
 
         if !self.is_activated() {
             warn!("virtio-mem: The device is not activated yet. Spurious event received: {source}");
+            self.drain_queue_events();
             return;
         }
 

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

@@ -67,6 +67,8 @@ pub enum ActivateError {
     QueueMemoryError(QueueError),
     /// The driver didn't acknowledge a required feature: {0}
     RequiredFeatureNotAcked(&'static str),
+    /// Vsock backend: {0}
+    VsockBackend(vsock::VsockError),
 }
 
 /// Trait that helps in upcasting an object to Any

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
@@ -1072,6 +1081,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.
@@ -2589,4 +2608,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/net/event_handler.rs

@@ -114,6 +114,16 @@ impl MutEventSubscriber for Net {
                 "Net: The device is not yet activated. Spurious event received: {:?}",
                 source
             );
+            match source {
+                Self::PROCESS_VIRTQ_RX | Self::PROCESS_VIRTQ_TX => self.drain_queue_events(),
+                Self::PROCESS_RX_RATE_LIMITER => {
+                    self.rx_rate_limiter.event_handler();
+                }
+                Self::PROCESS_TX_RATE_LIMITER => {
+                    self.tx_rate_limiter.event_handler();
+                }
+                _ => (),
+            }
         }
     }
 

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

@@ -579,6 +579,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/pmem/event_handler.rs

@@ -78,6 +78,13 @@ impl MutEventSubscriber for Pmem {
 
         if !self.is_activated() {
             warn!("pmem: The device is not activated yet. Spurious event received from {source}");
+            match source {
+                Self::PROCESS_PMEM_QUEUE => self.drain_queue_events(),
+                Self::PROCESS_RATE_LIMITER => {
+                    self.rate_limiter.event_handler();
+                }
+                _ => (),
+            }
             return;
         }
 

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)]