don't assume two queues

2 files changed, 32 insertions, 45 deletions

diff --git a/devices/src/virtio/controller.rs b/devices/src/virtio/controller.rs
index 4930e44..be7228a 100644
--- a/devices/src/virtio/controller.rs
+++ b/devices/src/virtio/controller.rs
@@ -105,10 +105,8 @@ pub enum Request {
         shm: MaybeOwnedFd<SharedMemory>,
         interrupt: MaybeOwnedFd<UnixSeqpacket>,
         interrupt_resample_evt: MaybeOwnedFd<EventFd>,
-        in_queue: Queue,
-        out_queue: Queue,
-        in_queue_evt: MaybeOwnedFd<EventFd>,
-        out_queue_evt: MaybeOwnedFd<EventFd>,
+        queues: Vec<Queue>,
+        queue_evts: Vec<MaybeOwnedFd<EventFd>>,
     },
 
     Reset,
@@ -162,22 +160,21 @@ impl SerializeWithFds for Request {
             }
 
             Activate {
-                shm: _,
-                interrupt: _,
-                interrupt_resample_evt: _,
-                in_queue,
-                out_queue,
-                in_queue_evt: _,
-                out_queue_evt: _,
+                shm,
+                interrupt,
+                interrupt_resample_evt,
+                queues,
+                queue_evts,
             } => {
                 let mut sv = serializer.serialize_struct_variant("Request", 8, "Activate", 7)?;
-                sv.serialize_field("shm", &())?;
-                sv.serialize_field("interrupt", &())?;
-                sv.serialize_field("interrupt_resample_evt", &())?;
-                sv.serialize_field("in_queue", in_queue)?;
-                sv.serialize_field("out_queue", out_queue)?;
-                sv.serialize_field("in_queue_evt", &())?;
-                sv.serialize_field("out_queue_evt", &())?;
+                sv.serialize_field("shm", &SerializeAdapter::new(shm))?;
+                sv.serialize_field("interrupt", &SerializeAdapter::new(interrupt))?;
+                sv.serialize_field(
+                    "interrupt_resample_evt",
+                    &SerializeAdapter::new(interrupt_resample_evt),
+                )?;
+                sv.serialize_field("queues", queues)?;
+                sv.serialize_field("queue_evts", &SerializeAdapter::new(queue_evts))?;
                 sv.end()
             }
 
@@ -242,19 +239,15 @@ impl SerializeWithFds for Request {
                 shm,
                 interrupt,
                 interrupt_resample_evt,
-                in_queue,
-                out_queue,
-                in_queue_evt,
-                out_queue_evt,
+                queues,
+                queue_evts,
             } => {
                 let mut sv = serializer.serialize_struct_variant("Request", 8, "Activate", 2)?;
                 sv.serialize_field("shm", shm)?;
                 sv.serialize_field("interrupt", interrupt)?;
                 sv.serialize_field("interrupt_resample_evt", interrupt_resample_evt)?;
-                sv.serialize_field("in_queue", in_queue)?;
-                sv.serialize_field("out_queue", out_queue)?;
-                sv.serialize_field("in_queue_evt", in_queue_evt)?;
-                sv.serialize_field("out_queue_evt", out_queue_evt)?;
+                sv.serialize_field("queues", queues)?;
+                sv.serialize_field("queue_evts", queue_evts)?;
                 sv.end()
             }
 
@@ -463,14 +456,8 @@ impl<'de> DeserializeWithFds<'de> for Request {
                                     interrupt_resample_evt: seq
                                         .next_element()?
                                         .ok_or_else(|| too_short(2))?,
-                                    in_queue: seq.next_element()?.ok_or_else(|| too_short(3))?,
-                                    out_queue: seq.next_element()?.ok_or_else(|| too_short(4))?,
-                                    in_queue_evt: seq
-                                        .next_element()?
-                                        .ok_or_else(|| too_short(5))?,
-                                    out_queue_evt: seq
-                                        .next_element()?
-                                        .ok_or_else(|| too_short(6))?,
+                                    queues: seq.next_element()?.ok_or_else(|| too_short(3))?,
+                                    queue_evts: seq.next_element()?.ok_or_else(|| too_short(4))?,
                                 })
                             }
                         }
@@ -811,7 +798,7 @@ impl VirtioDevice for Controller {
         &mut self,
         mem: GuestMemory,
         interrupt: Interrupt,
-        mut queues: Vec<Queue>,
+        queues: Vec<Queue>,
         queue_evts: Vec<EventFd>,
     ) {
         if queues.len() != QUEUE_SIZES.len() || queue_evts.len() != QUEUE_SIZES.len() {
@@ -836,10 +823,11 @@ impl VirtioDevice for Controller {
             shm: MaybeOwnedFd::new_borrowed(&mem),
             interrupt: MaybeOwnedFd::new_borrowed(&theirs),
             interrupt_resample_evt: MaybeOwnedFd::new_borrowed(interrupt.get_resample_evt()),
-            in_queue: queues.remove(0),
-            out_queue: queues.remove(0),
-            in_queue_evt: MaybeOwnedFd::new_borrowed(&queue_evts[0]),
-            out_queue_evt: MaybeOwnedFd::new_borrowed(&queue_evts[1]),
+            queues,
+            queue_evts: queue_evts
+                .iter()
+                .map(|e| MaybeOwnedFd::new_borrowed(e))
+                .collect(),
         }) {
             panic!("failed to send Activate: {}", e);
         }
diff --git a/src/wl.rs b/src/wl.rs
index 8ae8856..bf8989e 100644
--- a/src/wl.rs
+++ b/src/wl.rs
@@ -7,6 +7,7 @@ use devices::virtio::{
 use msg_socket::MsgSocket;
 use std::fs::remove_file;
 use sys_util::{error, net::UnixSeqpacketListener, GuestMemory};
+use vm_control::MaybeOwnedFd;
 
 #[cfg(any(target_arch = "arm", target_arch = "aarch64"))]
 pub use aarch64::arch_memory_regions;
@@ -92,10 +93,8 @@ fn main() {
                 shm,
                 interrupt,
                 interrupt_resample_evt,
-                in_queue,
-                out_queue,
-                in_queue_evt,
-                out_queue_evt,
+                queues,
+                queue_evts,
             }) => {
                 let shm = shm.owned();
 
@@ -112,8 +111,8 @@ fn main() {
                         interrupt,
                         interrupt_resample_evt.owned(),
                     )),
-                    vec![in_queue, out_queue],
-                    vec![in_queue_evt.owned(), out_queue_evt.owned()],
+                    queues,
+                    queue_evts.into_iter().map(MaybeOwnedFd::owned).collect(),
                 );
 
                 println!("activated Wl");