prepare to intercept VM control

2 files changed, 63 insertions, 18 deletions

diff --git a/devices/src/virtio/remote.rs b/devices/src/virtio/remote.rs
index e7f7967..b922264 100644
--- a/devices/src/virtio/remote.rs
+++ b/devices/src/virtio/remote.rs
@@ -13,7 +13,7 @@ use msg_socket2::{
 use std::fmt::{self, Formatter};
 use sys_util::net::UnixSeqpacket;
 use sys_util::{EventFd, SharedMemory};
-use vm_control::MaybeOwnedFd;
+use vm_control::{MaybeOwnedFd, VmMemoryControlRequestSocket};
 
 use crate::pci::{PciAddress, PciBarConfiguration, PciCapability, PciCapabilityID};
 use crate::virtio::Queue;
@@ -50,7 +50,7 @@ impl PciCapability for RemotePciCapability {
 pub enum Request {
     Create {
         memory_params: MemoryParams,
-        vm_control_socket: MaybeOwnedFd<UnixSeqpacket>,
+        vm_control_socket: MaybeOwnedFd<VmMemoryControlRequestSocket>,
     },
 
     DebugLabel,
diff --git a/src/ext/wl_main.rs b/src/ext/wl_main.rs
index 0b8d6a3..758d5a7 100644
--- a/src/ext/wl_main.rs
+++ b/src/ext/wl_main.rs
@@ -4,13 +4,15 @@
 
 use std::env::args_os;
 use std::fs::remove_file;
-use std::io::{stdout, IoSlice, Write};
+use std::io::{stdout, Write};
 use std::os::unix::prelude::*;
 use std::process;
 
 use devices::virtio::{remote, virtualized};
+use msg_socket::{MsgReceiver, MsgSender, MsgSocket};
 use sys_util::net::{UnixSeqpacket, UnixSeqpacketListener};
-use sys_util::{PollContext, PollToken, ScmSocket};
+use sys_util::{PollContext, PollToken};
+use vm_control::{VmMemoryRequest, VmMemoryResponse};
 
 fn main() {
     // Create and display the incoming socket.
@@ -30,7 +32,8 @@ fn main() {
     let client_virtio_device_msg_socket: msg_socket2::Socket<remote::Response, remote::Request> =
         msg_socket2::Socket::new(conn);
 
-    let (memory_params, client_vm_control_socket) = match client_virtio_device_msg_socket.recv() {
+    let (memory_params, client_vm_control_msg_socket) = match client_virtio_device_msg_socket.recv()
+    {
         Ok(remote::Request::Create {
             memory_params,
             vm_control_socket,
@@ -50,11 +53,12 @@ fn main() {
 
     let (server_vm_control_socket, ext_vm_control_socket) =
         UnixSeqpacket::pair().expect("pair failed");
+    let server_vm_control_msg_socket = MsgSocket::new(server_vm_control_socket);
 
     server_virtio_device_msg_socket
         .send(virtualized::Request::Create {
             memory_params,
-            ext_socket: ext_vm_control_socket, // TODO: proxy rather than passing through
+            ext_socket: ext_vm_control_socket,
         })
         .expect("send failed");
 
@@ -68,9 +72,9 @@ fn main() {
 
     let poll_ctx = match PollContext::build_with(&[
         (&client_virtio_device_msg_socket, Token::ClientVirtioDevice),
-        (&client_vm_control_socket, Token::ClientVmControl),
+        (&client_vm_control_msg_socket, Token::ClientVmControl),
         (&server_virtio_device_msg_socket, Token::ServerVirtioDevice),
-        (&server_vm_control_socket, Token::ServerVmControl),
+        (&server_vm_control_msg_socket, Token::ServerVmControl),
     ]) {
         Ok(pc) => pc,
         Err(e) => panic!("failed creating PollContext: {}", e),
@@ -132,11 +136,26 @@ fn main() {
                 }
 
                 Token::ClientVmControl => {
-                    let (buf, fds) = client_vm_control_socket
-                        .recv_as_vec_with_fds()
-                        .expect("recv failed");
-                    server_vm_control_socket
-                        .send_with_fds(&[IoSlice::new(&buf)], &fds[..])
+                    use VmMemoryResponse::*;
+                    let msg = match client_vm_control_msg_socket.recv().expect("recv failed") {
+                        RegisterMemory { pfn, slot } => RegisterMemory { pfn, slot },
+                        AllocateAndRegisterGpuMemory {
+                            fd,
+                            pfn,
+                            slot,
+                            desc,
+                        } => AllocateAndRegisterGpuMemory {
+                            fd,
+                            pfn,
+                            slot,
+                            desc,
+                        },
+                        Ok => Ok,
+                        Err(error) => Err(error),
+                    };
+
+                    server_vm_control_msg_socket
+                        .send(dbg!(&msg))
                         .expect("send failed");
                 }
 
@@ -174,11 +193,37 @@ fn main() {
                 }
 
                 Token::ServerVmControl => {
-                    let (buf, fds) = server_vm_control_socket
-                        .recv_as_vec_with_fds()
-                        .expect("recv failed");
-                    client_vm_control_socket
-                        .send_with_fds(&[IoSlice::new(&buf)], &fds[..])
+                    use VmMemoryRequest::*;
+                    let msg = match server_vm_control_msg_socket.recv().expect("recv failed") {
+                        RegisterMemory(fd, size) => RegisterMemory(fd, size),
+                        RegisterFdAtPciBarOffset(alloc, fd, size, offset) => {
+                            RegisterFdAtPciBarOffset(alloc, fd, size, offset)
+                        }
+                        UnregisterMemory(slot) => UnregisterMemory(slot),
+                        AllocateAndRegisterGpuMemory {
+                            width,
+                            height,
+                            format,
+                        } => AllocateAndRegisterGpuMemory {
+                            width,
+                            height,
+                            format,
+                        },
+                        RegisterMmapMemory {
+                            fd,
+                            size,
+                            offset,
+                            gpa,
+                        } => RegisterMmapMemory {
+                            fd,
+                            size,
+                            offset,
+                            gpa,
+                        },
+                    };
+
+                    client_vm_control_msg_socket
+                        .send(dbg!(&msg))
                         .expect("send failed");
                 }
             }