devices/mmio: Automatically enable device_idx feature for queues

Instead of each device manually enabling the event_idx for each queue, let's
make the transport layer configure the queues properly based on the acknowledged
features.

If it is necessary to disable this for some specific queue in the future
(unlikely) we could an option for this in QueueConfig or the device could
override this.

Signed-off-by: Matej Hrica <mhrica@redhat.com>

Author: mtjhrc

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

@@ -403,14 +403,11 @@ impl VirtioDevice for Block {
             panic!("virtio_blk: worker thread already exists");
         }
 
-        let [mut blk_q]: [_; NUM_QUEUES] = queues.try_into().map_err(|_| {
+        let [blk_q]: [_; NUM_QUEUES] = queues.try_into().map_err(|_| {
             error!("Cannot perform activate. Expected {} queue(s)", NUM_QUEUES);
             ActivateError::BadActivate
         })?;
 
-        let event_idx: bool = (self.acked_features & (1 << VIRTIO_RING_F_EVENT_IDX)) != 0;
-        blk_q.queue.set_event_idx(event_idx);
-
         let disk = match self.disk.take() {
             Some(d) => d,
             None => DiskProperties::new(

src/devices/src/virtio/fs/device.rs

@@ -169,13 +169,10 @@ impl VirtioDevice for Fs {
             panic!("virtio_fs: worker thread already exists");
         }
 
-        let event_idx: bool = (self.acked_features & (1 << VIRTIO_RING_F_EVENT_IDX)) != 0;
-
         // Extract queues and eventfds from DeviceQueues.
         let mut worker_queues = Vec::with_capacity(queues.len());
         let mut queue_evts = Vec::with_capacity(queues.len());
-        for mut dq in queues {
-            dq.queue.set_event_idx(event_idx);
+        for dq in queues {
             worker_queues.push(dq.queue);
             queue_evts.push(dq.event);
         }

src/devices/src/virtio/gpu/worker.rs

@@ -61,7 +61,8 @@ impl Worker {
         let control_evt = control_q.event.try_clone().unwrap();
         // SAFETY: control_evt is valid for the duration of the fcntl calls.
         let fd = unsafe { BorrowedFd::borrow_raw(control_evt.as_raw_fd()) };
-        let flags = OFlag::from_bits_retain(fcntl(fd, FcntlArg::F_GETFL).unwrap()) & !OFlag::O_NONBLOCK;
+        let flags =
+            OFlag::from_bits_retain(fcntl(fd, FcntlArg::F_GETFL).unwrap()) & !OFlag::O_NONBLOCK;
         fcntl(fd, FcntlArg::F_SETFL(flags)).unwrap();
 
         Self {

src/devices/src/virtio/mmio.rs

@@ -310,6 +310,11 @@ impl MmioTransport {
             .collect();
 
         let mut locked_device = self.locked_device();
+        let event_idx_enabled =
+            (locked_device.acked_features() & (1 << VIRTIO_RING_F_EVENT_IDX)) != 0;
+        for dq in &mut device_queues {
+            dq.queue.set_event_idx(event_idx_enabled);
+        }
         locked_device
             .activate(self.mem.clone(), self.interrupt.clone(), device_queues)
             .expect("Failed to activate device");

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

@@ -176,15 +176,11 @@ impl VirtioDevice for Net {
         interrupt: InterruptTransport,
         queues: Vec<DeviceQueue>,
     ) -> ActivateResult {
-        let [mut rx_q, mut tx_q]: [_; NUM_QUEUES] = queues.try_into().map_err(|_| {
+        let [rx_q, tx_q]: [_; NUM_QUEUES] = queues.try_into().map_err(|_| {
             error!("Cannot perform activate. Expected {} queue(s)", NUM_QUEUES);
             ActivateError::BadActivate
         })?;
 
-        let event_idx: bool = (self.acked_features & (1 << VIRTIO_RING_F_EVENT_IDX)) != 0;
-        rx_q.queue.set_event_idx(event_idx);
-        tx_q.queue.set_event_idx(event_idx);
-
         match NetWorker::new(
             rx_q,
             tx_q,

src/devices/src/virtio/snd/device.rs

@@ -2,13 +2,12 @@ use std::io::Write;
 use std::thread::JoinHandle;
 
 use utils::eventfd::EventFd;
-use virtio_bindings::virtio_ring::VIRTIO_RING_F_EVENT_IDX;
 use vm_memory::{ByteValued, GuestMemoryMmap};
 
 use super::super::{ActivateError, ActivateResult, DeviceQueue, QueueConfig, VirtioDevice};
 use super::virtio_sound::VirtioSoundConfig;
 use super::worker::SndWorker;
-use super::{defs, defs::uapi, defs::QUEUE_INDEXES, Error};
+use super::{defs, defs::uapi, Error};
 
 use crate::virtio::{DeviceState, InterruptTransport};
 
@@ -100,7 +99,7 @@ impl VirtioDevice for Snd {
         &mut self,
         mem: GuestMemoryMmap,
         interrupt: InterruptTransport,
-        mut queues: Vec<DeviceQueue>,
+        queues: Vec<DeviceQueue>,
     ) -> ActivateResult {
         if self.worker_thread.is_some() {
             panic!("virtio_snd: worker thread already exists");
@@ -115,11 +114,6 @@ impl VirtioDevice for Snd {
             return Err(ActivateError::BadActivate);
         }
 
-        let event_idx: bool = (self.acked_features & (1 << VIRTIO_RING_F_EVENT_IDX)) != 0;
-        for idx in QUEUE_INDEXES {
-            queues[idx].queue.set_event_idx(event_idx);
-        }
-
         let worker = SndWorker::new(
             queues,
             interrupt.clone(),