summary refs log tree commit diff
path: root/src/wl.rs
diff options
context:
space:
mode:
Diffstat (limited to 'src/wl.rs')
-rw-r--r--src/wl.rs66
1 files changed, 29 insertions, 37 deletions
diff --git a/src/wl.rs b/src/wl.rs
index c04ec06..be2ca2e 100644
--- a/src/wl.rs
+++ b/src/wl.rs
@@ -1,22 +1,19 @@
 // SPDX-License-Identifier: BSD-3-Clause
 
 use devices::virtio::{
-    BincodeRequest, BincodeResponse, InterruptProxy, InterruptProxyEvent, MsgOnSocketRequest,
-    MsgOnSocketResponse, RemotePciCapability, VirtioDevice, Wl,
+    InterruptProxy, InterruptProxyEvent, RemotePciCapability, Request, Response, VirtioDevice, Wl,
 };
 use msg_socket::MsgSocket;
-use poly_msg_socket::PolyMsgSocket;
 use std::collections::BTreeMap;
 use std::fs::remove_file;
-use sys_util::{error, net::UnixSeqpacketListener, warn, GuestMemory};
+use sys_util::{error, net::UnixSeqpacketListener, GuestMemory};
 
 #[cfg(any(target_arch = "arm", target_arch = "aarch64"))]
 pub use aarch64::arch_memory_regions;
 #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
 pub use x86_64::arch_memory_regions;
 
-type Socket =
-    PolyMsgSocket<MsgOnSocketResponse, MsgOnSocketRequest, BincodeResponse, BincodeRequest>;
+type Socket = msg_socket2::Socket<Response, Request>;
 
 fn main() {
     eprintln!("hello world");
@@ -30,13 +27,13 @@ fn main() {
 
     // Receive connection from crosvm.
     let conn = server.accept().expect("accept failed");
-    let msg_socket: Socket = PolyMsgSocket::new(conn);
+    let msg_socket: Socket = msg_socket2::Socket::new(conn);
 
     let (vm_socket, memory_params) = match msg_socket.recv() {
-        Ok(poly_msg_socket::Value::MsgOnSocket(MsgOnSocketRequest::Create {
+        Ok(Request::Create {
             vm_socket,
             memory_params,
-        })) => (MsgSocket::new(vm_socket.owned()), memory_params),
+        }) => (MsgSocket::new(vm_socket.owned()), memory_params),
 
         Ok(msg) => {
             panic!("received unexpected message: {:?}", msg);
@@ -53,51 +50,48 @@ fn main() {
     let mut wl = Wl::new(wayland_paths, vm_socket, None).unwrap();
 
     loop {
-        use poly_msg_socket::Value::*;
         match msg_socket.recv() {
-            Ok(Bincode(BincodeRequest::DebugLabel)) => {
+            Ok(Request::DebugLabel) => {
                 let result = wl.debug_label();
-                if let Err(e) = msg_socket.send(BincodeResponse::DebugLabel(result)) {
+                if let Err(e) = msg_socket.send(Response::DebugLabel(result)) {
                     panic!("responding to DebugLabel failed: {}", e);
                 }
             }
 
-            Ok(MsgOnSocket(MsgOnSocketRequest::DeviceType)) => {
+            Ok(Request::DeviceType) => {
                 let result = wl.device_type();
-                if let Err(e) = msg_socket.send(MsgOnSocketResponse::DeviceType(result)) {
+                if let Err(e) = msg_socket.send(Response::DeviceType(result)) {
                     panic!("responding to DeviceType failed: {}", e);
                 }
             }
 
-            Ok(Bincode(BincodeRequest::QueueMaxSizes)) => {
+            Ok(Request::QueueMaxSizes) => {
                 let result = wl.queue_max_sizes();
-                if let Err(e) = msg_socket.send(BincodeResponse::QueueMaxSizes(result)) {
+                if let Err(e) = msg_socket.send(Response::QueueMaxSizes(result)) {
                     panic!("responding to QueueMaxSizes failed: {}", e);
                 }
             }
 
-            Ok(MsgOnSocket(MsgOnSocketRequest::Features)) => {
+            Ok(Request::Features) => {
                 let result = wl.features();
-                if let Err(e) = msg_socket.send(MsgOnSocketResponse::Features(result)) {
+                if let Err(e) = msg_socket.send(Response::Features(result)) {
                     panic!("responding to Features failed: {}", e);
                 }
             }
 
-            Ok(MsgOnSocket(MsgOnSocketRequest::AckFeatures(value))) => wl.ack_features(value),
+            Ok(Request::AckFeatures(value)) => wl.ack_features(value),
 
-            Ok(Bincode(BincodeRequest::ReadConfig { offset, len })) => {
+            Ok(Request::ReadConfig { offset, len }) => {
                 let mut data = vec![0; len];
                 wl.read_config(offset, &mut data);
-                if let Err(e) = msg_socket.send(BincodeResponse::ReadConfig(data)) {
+                if let Err(e) = msg_socket.send(Response::ReadConfig(data)) {
                     panic!("responding to ReadConfig failed: {}", e);
                 }
             }
 
-            Ok(Bincode(BincodeRequest::WriteConfig { offset, ref data })) => {
-                wl.write_config(offset, data)
-            }
+            Ok(Request::WriteConfig { offset, ref data }) => wl.write_config(offset, data),
 
-            Ok(MsgOnSocket(MsgOnSocketRequest::Activate {
+            Ok(Request::Activate {
                 shm,
                 interrupt,
                 interrupt_resample_evt,
@@ -105,7 +99,7 @@ fn main() {
                 out_queue,
                 in_queue_evt,
                 out_queue_evt,
-            })) => {
+            }) => {
                 let shm = shm.owned();
 
                 let regions = arch_memory_regions(memory_params);
@@ -128,45 +122,43 @@ fn main() {
                 println!("activated Wl");
             }
 
-            Ok(MsgOnSocket(MsgOnSocketRequest::Reset)) => {
+            Ok(Request::Reset) => {
                 let result = wl.reset();
-                if let Err(e) = msg_socket.send(MsgOnSocketResponse::Reset(result)) {
+                if let Err(e) = msg_socket.send(Response::Reset(result)) {
                     panic!("responding to Reset failed: {}", e);
                 }
             }
 
-            Ok(Bincode(BincodeRequest::GetDeviceBars(address))) => {
+            Ok(Request::GetDeviceBars(address)) => {
                 let result = wl.get_device_bars(address);
-                if let Err(e) = msg_socket.send(BincodeResponse::GetDeviceBars(result)) {
+                if let Err(e) = msg_socket.send(Response::GetDeviceBars(result)) {
                     panic!("responding to GetDeviceBars failed: {}", e);
                 }
             }
 
-            Ok(Bincode(BincodeRequest::GetDeviceCaps)) => {
+            Ok(Request::GetDeviceCaps) => {
                 let result = wl
                     .get_device_caps()
                     .into_iter()
                     .map(|c| RemotePciCapability::from(&*c))
                     .collect();
-                if let Err(e) = msg_socket.send(BincodeResponse::GetDeviceCaps(result)) {
+                if let Err(e) = msg_socket.send(Response::GetDeviceCaps(result)) {
                     panic!("responding to GetDeviceCaps failed: {}", e);
                 }
             }
 
-            Ok(MsgOnSocket(MsgOnSocketRequest::Kill)) => {
+            Ok(Request::Kill) => {
                 // Will block until worker shuts down.
                 drop(wl);
 
-                if let Err(e) = msg_socket.send(MsgOnSocketResponse::Kill) {
+                if let Err(e) = msg_socket.send(Response::Kill) {
                     error!("responding to Kill failed: {}", e);
                 }
 
                 break;
             }
 
-            Ok(MsgOnSocket(msg @ MsgOnSocketRequest::Create { .. })) => {
-                panic!("unexpected message {:?}", msg)
-            }
+            Ok(msg @ Request::Create { .. }) => panic!("unexpected message {:?}", msg),
 
             Err(e) => panic!("recv failed: {}", e),
         }