hacky working out-of-process virtio_wl

1 files changed, 113 insertions, 0 deletions

diff --git a/src/wl.rs b/src/wl.rs
new file mode 100644
index 0000000..419fb67
--- /dev/null
+++ b/src/wl.rs
@@ -0,0 +1,113 @@
+// SPDX-License-Identifier: BSD-3-Clause
+
+use std::os::unix::prelude::*;
+
+use devices::virtio::{InterruptProxy, InterruptProxyEvent, SingleFd, Worker};
+use msg_socket::{MsgReceiver, MsgSocket};
+use std::collections::BTreeMap;
+use std::fs::remove_file;
+use sys_util::{
+    net::{UnixSeqpacket, UnixSeqpacketListener},
+    EventFd, GuestMemory, SharedMemory,
+};
+use vm_control::VmMemoryControlRequestSocket;
+
+#[cfg(any(target_arch = "arm", target_arch = "aarch64"))]
+pub use aarch64::{arch_memory_regions, MemoryParams};
+#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+pub use x86_64::{arch_memory_regions, MemoryParams};
+
+type Socket = MsgSocket<(), SingleFd>;
+
+fn main() {
+    eprintln!("hello world");
+
+    // Create and display the socket.
+    let mut path = std::env::var("XDG_RUNTIME_DIR").expect("XDG_RUNTIME_DIR missing");
+    path.push_str("/crosvm-wl.sock");
+    let _ = remove_file(&path);
+    let server = UnixSeqpacketListener::bind(&path).expect("failed to create control socket");
+    println!("{}", path);
+
+    // Receive connection from crosvm.
+    let conn = server.accept().expect("accept failed");
+    let msg_socket: Socket = MsgSocket::new(conn);
+
+    loop {
+        match msg_socket.recv() {
+            Ok(SingleFd {
+                memfd,
+                interrupt,
+                interrupt_resample_evt,
+                in_queue,
+                out_queue,
+                vm_socket,
+                use_transition_flags,
+                in_queue_evt,
+                out_queue_evt,
+                kill_evt,
+            }) => {
+                let shm = unsafe { SharedMemory::from_raw_fd(memfd.as_raw_fd()) };
+                std::mem::forget(memfd);
+
+                let regions = arch_memory_regions(MemoryParams {
+                    size: shm.size(),
+                    has_bios: false,
+                });
+                let mem =
+                    GuestMemory::with_memfd(&regions, shm).expect("GuestMemory::with_memfd failed");
+
+                let interrupt: MsgSocket<InterruptProxyEvent, ()> = MsgSocket::new(unsafe {
+                    let sock = UnixSeqpacket::from_raw_fd(interrupt.as_raw_fd());
+                    std::mem::forget(interrupt);
+                    sock
+                });
+                let vm_socket: VmMemoryControlRequestSocket = MsgSocket::new(unsafe {
+                    let sock = UnixSeqpacket::from_raw_fd(vm_socket.as_raw_fd());
+                    std::mem::forget(vm_socket);
+                    sock
+                });
+
+                let mut wayland_paths = BTreeMap::new();
+                wayland_paths.insert("".into(), "/run/user/1000/wayland-0".into());
+
+                let mut worker = Worker::new(
+                    mem,
+                    Box::new(InterruptProxy::new(interrupt, unsafe {
+                        let evt = EventFd::from_raw_fd(interrupt_resample_evt.as_raw_fd());
+                        std::mem::forget(interrupt_resample_evt);
+                        evt
+                    })),
+                    in_queue,
+                    out_queue,
+                    wayland_paths,
+                    vm_socket,
+                    use_transition_flags,
+                    None,
+                );
+
+                worker.run(
+                    vec![
+                        unsafe {
+                            let evt = EventFd::from_raw_fd(in_queue_evt.as_raw_fd());
+                            std::mem::forget(in_queue_evt);
+                            evt
+                        },
+                        unsafe {
+                            let evt = EventFd::from_raw_fd(out_queue_evt.as_raw_fd());
+                            std::mem::forget(out_queue_evt);
+                            evt
+                        },
+                    ],
+                    unsafe {
+                        let evt = EventFd::from_raw_fd(kill_evt.as_raw_fd());
+                        std::mem::forget(kill_evt);
+                        evt
+                    },
+                );
+            }
+
+            Err(e) => panic!("recv failed {:?}", e),
+        }
+    }
+}