feat(examples): add vsock_server regression test

Cargo.toml

@@ -28,6 +28,7 @@ members = [
     "examples/wasm-test",
     "examples/hermit-wasm",
     "examples/vsock",
+    "examples/vsock_server",
     "hermit",
     "hermit-abi",
 ]

examples/vsock_server/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "vsock_server"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+
+[target.'cfg(unix)'.dependencies]
+libc = { version = "0.2" }
+
+[target.'cfg(target_os = "hermit")'.dependencies.hermit-abi]
+path = "../../hermit-abi"
+
+[target.'cfg(target_os = "hermit")'.dependencies.hermit]
+path = "../../hermit"
+default-features = false
+
+[features]
+default = ["pci", "pci-ids", "acpi", "vsock"]
+pci = ["hermit/pci"]
+pci-ids = ["hermit/pci-ids"]
+acpi = ["hermit/acpi"]
+vsock = ["hermit/vsock"]

examples/vsock_server/src/main.rs

@@ -0,0 +1,42 @@
+//! Regression test for hermit-os/kernel#2433:
+//! vsock listener cannot accept a second connection.
+//!
+//! The VM runs a server that accepts CONNECTIONS sequential connections,
+//! reads "ping", writes "pong", and closes each one. The host-side client
+//! is driven by xtask (see xtask/src/ci/qemu.rs test_vsock_server).
+use std::io::{Read, Write};
+
+#[cfg(target_os = "hermit")]
+use hermit as _;
+
+mod vsock;
+
+use vsock::VsockListener;
+
+const PORT: u32 = 9975;
+pub const CONNECTIONS: usize = 2;
+
+fn main() {
+	println!("vsock_server_test: waiting for {CONNECTIONS} sequential connections on port {PORT}");
+
+	let listener = VsockListener::bind(PORT).expect("bind failed");
+	println!("[server] listening on port {PORT}");
+
+	for i in 1..=CONNECTIONS {
+		println!("[server] waiting for connection {i}/{CONNECTIONS}");
+		let (mut stream, _addr) = listener.accept().expect("accept failed");
+		println!("[server] accepted connection {i}");
+
+		let mut buf = [0u8; 64];
+		let n = stream.read(&mut buf).expect("read failed");
+		let msg = std::str::from_utf8(&buf[..n]).unwrap_or("<invalid>");
+		println!("[server] received: {msg:?}");
+		assert_eq!(msg, "ping", "connection {i}: unexpected message");
+
+		stream.write_all(b"pong").expect("write failed");
+		println!("[server] sent pong for connection {i}");
+		// stream drops here, closing the connection
+	}
+
+	println!("vsock_server_test: PASSED");
+}

examples/vsock_server/src/vsock.rs

@@ -0,0 +1,267 @@
+#![allow(dead_code)]
+
+/// Virtio socket support for Rust. Implements VsockListener and VsockStream
+/// which are analogous to the `std::net::TcpListener` and `std::net::TcpStream`
+/// types.
+///
+/// The implementation is derived from https://github.com/rust-vsock/vsock-rs
+/// and adapted for HermitOS.
+use std::io::{self, Read, Result, Write};
+use std::mem::size_of;
+use std::os::fd::AsRawFd;
+#[cfg(target_os = "hermit")]
+use std::os::hermit::io::{FromRawFd, OwnedFd, RawFd};
+#[cfg(unix)]
+use std::os::unix::io::{FromRawFd, OwnedFd, RawFd};
+
+#[cfg(target_os = "hermit")]
+use hermit_abi::{
+	accept, bind, close, connect, listen, read, sa_family_t, sockaddr, sockaddr_vm, socket,
+	socklen_t, write, AF_VSOCK, SOCK_STREAM, VMADDR_CID_ANY,
+};
+#[cfg(unix)]
+use libc::{
+	accept, bind, c_void, close, connect, listen, read, sa_family_t, sockaddr, sockaddr_vm, socket,
+	socklen_t, write, AF_VSOCK, SOCK_STREAM, VMADDR_CID_ANY,
+};
+
+#[derive(Copy, Clone)]
+#[repr(transparent)]
+pub struct VsockAddr(pub sockaddr_vm);
+
+impl VsockAddr {
+	pub fn new(cid: u32, port: u32) -> Self {
+		#[cfg(target_os = "hermit")]
+		let vsock_addr_len: socklen_t = size_of::<sockaddr_vm>().try_into().unwrap();
+		let vsock_addr = sockaddr_vm {
+			#[cfg(target_os = "hermit")]
+			svm_len: vsock_addr_len.try_into().unwrap(),
+			svm_reserved1: 0,
+			svm_family: AF_VSOCK as sa_family_t,
+			svm_cid: cid,
+			svm_port: port,
+			svm_zero: [0; 4],
+		};
+
+		Self(vsock_addr)
+	}
+}
+
+#[doc(hidden)]
+pub trait IsNegative {
+	fn is_negative(&self) -> bool;
+	#[allow(dead_code)]
+	fn negate(&self) -> i32;
+}
+
+macro_rules! impl_is_negative {
+    ($($t:ident)*) => ($(impl IsNegative for $t {
+        fn is_negative(&self) -> bool {
+            *self < 0
+        }
+
+        fn negate(&self) -> i32 {
+            i32::try_from(-(*self)).unwrap()
+        }
+    })*)
+}
+
+impl IsNegative for i32 {
+	fn is_negative(&self) -> bool {
+		*self < 0
+	}
+
+	fn negate(&self) -> i32 {
+		-(*self)
+	}
+}
+impl_is_negative! { i8 i16 i64 isize }
+
+#[cfg(unix)]
+fn check<T: IsNegative>(res: T) -> io::Result<T> {
+	if res.is_negative() {
+		Err(std::io::Error::last_os_error())
+	} else {
+		Ok(res)
+	}
+}
+
+#[cfg(target_os = "hermit")]
+fn check<T: std::ops::Neg<Output = T> + std::cmp::PartialOrd<T> + IsNegative>(
+	res: T,
+) -> io::Result<T> {
+	if res.is_negative() {
+		let e = match res.negate() {
+			hermit_abi::errno::EACCES => std::io::ErrorKind::PermissionDenied,
+			hermit_abi::errno::EADDRINUSE => std::io::ErrorKind::AddrInUse,
+			hermit_abi::errno::EADDRNOTAVAIL => std::io::ErrorKind::AddrNotAvailable,
+			hermit_abi::errno::EAGAIN => std::io::ErrorKind::WouldBlock,
+			hermit_abi::errno::ECONNABORTED => std::io::ErrorKind::ConnectionAborted,
+			hermit_abi::errno::ECONNREFUSED => std::io::ErrorKind::ConnectionRefused,
+			hermit_abi::errno::ECONNRESET => std::io::ErrorKind::ConnectionReset,
+			hermit_abi::errno::EEXIST => std::io::ErrorKind::AlreadyExists,
+			hermit_abi::errno::EINTR => std::io::ErrorKind::Interrupted,
+			hermit_abi::errno::EINVAL => std::io::ErrorKind::InvalidInput,
+			hermit_abi::errno::ENOENT => std::io::ErrorKind::NotFound,
+			hermit_abi::errno::ENOTCONN => std::io::ErrorKind::NotConnected,
+			hermit_abi::errno::EPERM => std::io::ErrorKind::PermissionDenied,
+			hermit_abi::errno::EPIPE => std::io::ErrorKind::BrokenPipe,
+			hermit_abi::errno::ETIMEDOUT => std::io::ErrorKind::TimedOut,
+			_ => {
+				println!("Unknown error number {}", res.negate());
+				std::io::ErrorKind::InvalidInput
+			}
+		};
+		Err(std::io::Error::from(e))
+	} else {
+		Ok(res)
+	}
+}
+
+/// A virtio socket server, listening for connections.
+#[derive(Debug)]
+pub struct VsockListener {
+	fd: OwnedFd,
+}
+
+impl VsockListener {
+	/// Create a new VsockListener which is bound and listening on the socket address.
+	pub fn bind(port: u32) -> io::Result<Self> {
+		unsafe {
+			let saddr = sockaddr_vm {
+				#[cfg(target_os = "hermit")]
+				svm_len: std::mem::size_of::<sockaddr_vm>().try_into().unwrap(),
+				svm_reserved1: 0,
+				svm_family: AF_VSOCK.try_into().unwrap(),
+				svm_cid: VMADDR_CID_ANY,
+				svm_port: port,
+				svm_zero: [0; 4],
+			};
+			let fd = socket(AF_VSOCK, SOCK_STREAM, 0);
+
+			check(bind(
+				fd,
+				&saddr as *const _ as *const sockaddr,
+				std::mem::size_of::<sockaddr_vm>().try_into().unwrap(),
+			))?;
+
+			// rust stdlib uses a 128 connection backlog
+			check(listen(fd, 128))?;
+
+			Ok(VsockListener {
+				fd: OwnedFd::from_raw_fd(fd),
+			})
+		}
+	}
+
+	/// Accept a new incoming connection from this listener.
+	pub fn accept(&self) -> io::Result<(VsockStream, VsockAddr)> {
+		let mut vsock_addr_len: socklen_t = size_of::<sockaddr_vm>().try_into().unwrap();
+		let mut vsock_addr = sockaddr_vm {
+			#[cfg(target_os = "hermit")]
+			svm_len: vsock_addr_len.try_into().unwrap(),
+			svm_reserved1: 0,
+			svm_family: AF_VSOCK as sa_family_t,
+			svm_cid: 0,
+			svm_port: 0,
+			svm_zero: [0; 4],
+		};
+
+		let fd = unsafe {
+			check(accept(
+				self.fd.as_raw_fd(),
+				&mut vsock_addr as *mut _ as *mut sockaddr,
+				&mut vsock_addr_len as *mut u32,
+			))?
+		};
+
+		Ok((VsockStream::new(fd), VsockAddr(vsock_addr)))
+	}
+}
+
+impl Drop for VsockListener {
+	fn drop(&mut self) {
+		unsafe {
+			let _ = close(self.fd.as_raw_fd());
+		}
+	}
+}
+
+pub struct VsockStream {
+	fd: OwnedFd,
+}
+
+impl VsockStream {
+	pub fn new(fd: RawFd) -> Self {
+		Self {
+			fd: unsafe { FromRawFd::from_raw_fd(fd) },
+		}
+	}
+
+	pub fn connect(addr: VsockAddr) -> io::Result<VsockStream> {
+		let len: socklen_t = size_of::<sockaddr_vm>().try_into().unwrap();
+		let fd = unsafe { socket(AF_VSOCK, SOCK_STREAM, 0) };
+
+		unsafe {
+			check(connect(
+				fd.as_raw_fd(),
+				&addr.0 as *const _ as *const sockaddr,
+				len,
+			))?
+		};
+
+		Ok(VsockStream::new(fd))
+	}
+}
+
+impl Read for VsockStream {
+	#[cfg(target_os = "hermit")]
+	fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
+		let result = unsafe { check(read(self.fd.as_raw_fd(), buf.as_mut_ptr(), buf.len()))? };
+		Ok(result.try_into().unwrap())
+	}
+
+	#[cfg(unix)]
+	fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
+		let result = unsafe {
+			check(read(
+				self.fd.as_raw_fd(),
+				buf.as_mut_ptr() as *mut c_void,
+				buf.len(),
+			))?
+		};
+		Ok(result.try_into().unwrap())
+	}
+}
+
+impl Write for VsockStream {
+	#[cfg(target_os = "hermit")]
+	fn write(&mut self, buf: &[u8]) -> Result<usize> {
+		let result = unsafe { check(write(self.fd.as_raw_fd(), buf.as_ptr(), buf.len()))? };
+		Ok(result.try_into().unwrap())
+	}
+
+	#[cfg(unix)]
+	fn write(&mut self, buf: &[u8]) -> Result<usize> {
+		let result: isize = unsafe {
+			check(write(
+				self.fd.as_raw_fd(),
+				buf.as_ptr() as *const c_void,
+				buf.len(),
+			))?
+		};
+		Ok(result.try_into().unwrap())
+	}
+
+	fn flush(&mut self) -> Result<()> {
+		Ok(())
+	}
+}
+
+impl Drop for VsockStream {
+	fn drop(&mut self) {
+		unsafe {
+			let _ = close(self.fd.as_raw_fd());
+		}
+	}
+}