extract create message from activate

1 files changed, 45 insertions, 57 deletions

diff --git a/devices/src/virtio/controller.rs b/devices/src/virtio/controller.rs
index 83834e4..815bb46 100644
--- a/devices/src/virtio/controller.rs
+++ b/devices/src/virtio/controller.rs
@@ -33,25 +33,27 @@ use std::os::unix::io::{AsRawFd, RawFd};
 use std::path::PathBuf;
 use std::thread;
 
-use msg_socket::{MsgReceiver, MsgSender};
-use sys_util::{error, EventFd, GuestMemory, PollContext, PollToken, Result, SharedMemory};
-
 use super::resource_bridge::*;
 use super::{Interrupt, InterruptProxyEvent, Queue, VirtioDevice, TYPE_WL, VIRTIO_F_VERSION_1};
 use vm_control::{MaybeOwnedFd, VmMemoryControlRequestSocket};
 
-use msg_socket::{MsgOnSocket, MsgSocket};
+use msg_socket::{MsgError, MsgOnSocket, MsgReceiver, MsgSender, MsgSocket};
 use sys_util::net::UnixSeqpacket;
+use sys_util::{error, EventFd, GuestMemory, PollContext, PollToken, SharedMemory};
 
 #[derive(Debug, MsgOnSocket)]
 pub enum Request {
+    Create {
+        // wayland_paths: Map<String, PathBuf>,
+        vm_socket: MaybeOwnedFd<UnixSeqpacket>,
+        // resource_bridge: Option<ResourceRequestSocket>,
+    },
     Activate {
         shm: MaybeOwnedFd<SharedMemory>,
         interrupt: MaybeOwnedFd<UnixSeqpacket>,
         interrupt_resample_evt: MaybeOwnedFd<EventFd>,
         in_queue: Queue,
         out_queue: Queue,
-        vm_socket: MaybeOwnedFd<UnixSeqpacket>,
         in_queue_evt: MaybeOwnedFd<EventFd>,
         out_queue_evt: MaybeOwnedFd<EventFd>,
     },
@@ -168,26 +170,26 @@ impl Worker {
 pub struct Controller {
     kill_evt: Option<EventFd>,
     worker_thread: Option<thread::JoinHandle<()>>,
-    wayland_paths: Map<String, PathBuf>,
-    vm_socket: Option<VmMemoryControlRequestSocket>,
-    resource_bridge: Option<ResourceRequestSocket>,
     use_transition_flags: bool,
     socket: Option<Socket>,
 }
 
 impl Controller {
-    pub fn new(
+    pub fn create(
         wayland_paths: Map<String, PathBuf>,
         vm_socket: VmMemoryControlRequestSocket,
         resource_bridge: Option<ResourceRequestSocket>,
         socket: Socket,
-    ) -> Result<Controller> {
+    ) -> Result<Controller, MsgError> {
+        socket.send(&Request::Create {
+            // wayland_paths,
+            vm_socket: MaybeOwnedFd::new_borrowed(&vm_socket),
+            // resource_bridge,
+        })?;
+
         Ok(Controller {
             kill_evt: None,
             worker_thread: None,
-            wayland_paths,
-            vm_socket: Some(vm_socket),
-            resource_bridge,
             use_transition_flags: false,
             socket: Some(socket),
         })
@@ -211,13 +213,6 @@ impl VirtioDevice for Controller {
     fn keep_fds(&self) -> Vec<RawFd> {
         let mut keep_fds = Vec::new();
 
-        if let Some(vm_socket) = &self.vm_socket {
-            keep_fds.push(vm_socket.as_raw_fd());
-        }
-        if let Some(resource_bridge) = &self.resource_bridge {
-            keep_fds.push(resource_bridge.as_raw_fd());
-        }
-
         if let Some(ref kill_evt) = self.kill_evt {
             keep_fds.push(kill_evt.as_raw_fd());
         }
@@ -267,45 +262,38 @@ impl VirtioDevice for Controller {
         };
         self.kill_evt = Some(self_kill_evt);
 
-        if let Some(vm_socket) = self.vm_socket.take() {
-            if let Some(socket) = self.socket.take() {
-                let wayland_paths = self.wayland_paths.clone();
-                let use_transition_flags = self.use_transition_flags;
-                let resource_bridge = self.resource_bridge.take();
-
-                let (ours, theirs) = UnixSeqpacket::pair().expect("pair failed");
-
-                if let Err(e) = socket.send(&Request::Activate {
-                    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),
-                    vm_socket: MaybeOwnedFd::new_borrowed(&vm_socket),
-                    in_queue_evt: MaybeOwnedFd::new_borrowed(&queue_evts[0]),
-                    out_queue_evt: MaybeOwnedFd::new_borrowed(&queue_evts[1]),
-                }) {
-                    error!("failed to send Activate: {}", e);
+        if let Some(socket) = self.socket.take() {
+            let use_transition_flags = self.use_transition_flags;
+
+            let (ours, theirs) = UnixSeqpacket::pair().expect("pair failed");
+
+            if let Err(e) = socket.send(&Request::Activate {
+                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]),
+            }) {
+                error!("failed to send Activate: {}", e);
+                return;
+            }
+
+            let worker_result =
+                thread::Builder::new()
+                    .name("virtio_wl".to_string())
+                    .spawn(move || {
+                        Worker::new(socket, interrupt, MsgSocket::new(ours)).run(kill_evt);
+                    });
+
+            match worker_result {
+                Err(e) => {
+                    error!("failed to spawn virtio_wl worker: {}", e);
                     return;
                 }
-
-                let worker_result =
-                    thread::Builder::new()
-                        .name("virtio_wl".to_string())
-                        .spawn(move || {
-                            Worker::new(socket, interrupt, MsgSocket::new(ours)).run(kill_evt);
-                        });
-
-                match worker_result {
-                    Err(e) => {
-                        error!("failed to spawn virtio_wl worker: {}", e);
-                        return;
-                    }
-                    Ok(join_handle) => {
-                        self.worker_thread = Some(join_handle);
-                    }
+                Ok(join_handle) => {
+                    self.worker_thread = Some(join_handle);
                 }
             }
         }