feat(uhyve): use v2 interface

On x86_64, the data address will be stored in the rcx register
to support 64-bit addresses.

This also removes the usage of ExitArgs, as it is a single integer.

Co-authored-by: Ellen Εμιλία Άννα Zscheile <fogti+devel@ytrizja.de>
Helped-by: Jonathan Klimt <jonathan.klimt@eonerc.rwth-aachen.de>

Author: n0toose

Cargo.lock

@@ -141,7 +141,7 @@ thiserror = { version = "2", default-features = false }
 time = { version = "0.3", default-features = false }
 volatile = "0.6"
 zerocopy = { version = "0.8", default-features = false }
-uhyve-interface = "0.1.4"
+uhyve-interface = "0.2.0"
 
 [dependencies.smoltcp]
 version = "0.12"
@@ -210,6 +210,7 @@ exclude = [
 ]
 
 [patch.crates-io]
+uhyve-interface = { git = "https://github.com/n0toose/uhyve", branch = "uhyve-if-v2_io-plus-rcx" }
 safe-mmio = { git = "https://github.com/hermit-os/safe-mmio", branch = "be" }
 
 [profile.profiling]

Cargo.toml

@@ -4,9 +4,12 @@ use core::task::Poll;
 
 use async_trait::async_trait;
 use embedded_io::{Read, ReadReady, Write};
-use uhyve_interface::parameters::WriteParams;
-use uhyve_interface::{GuestVirtAddr, Hypercall};
+use memory_addresses::VirtAddr;
+use uhyve_interface::GuestPhysAddr;
+use uhyve_interface::v2::Hypercall;
+use uhyve_interface::v2::parameters::WriteParams;
 
+use crate::arch::mm::paging;
 use crate::console::{CONSOLE, CONSOLE_WAKER};
 use crate::fd::{
 	AccessPermission, FileAttr, ObjectInterface, PollEvent, STDERR_FILENO, STDOUT_FILENO,
@@ -161,12 +164,16 @@ impl ObjectInterface for UhyveStdout {
 	async fn write(&self, buf: &[u8]) -> io::Result<usize> {
 		let write_params = WriteParams {
 			fd: STDOUT_FILENO,
-			buf: GuestVirtAddr::from_ptr(buf.as_ptr()),
-			len: buf.len(),
+			buf: GuestPhysAddr::new(
+				paging::virtual_to_physical(VirtAddr::from_ptr(buf.as_ptr()))
+					.unwrap()
+					.as_u64(),
+			),
+			len: buf.len().try_into().unwrap(),
 		};
 		uhyve_hypercall(Hypercall::FileWrite(&write_params));
 
-		Ok(write_params.len)
+		Ok(write_params.len.try_into().unwrap())
 	}
 
 	async fn isatty(&self) -> io::Result<bool> {
@@ -200,12 +207,16 @@ impl ObjectInterface for UhyveStderr {
 	async fn write(&self, buf: &[u8]) -> io::Result<usize> {
 		let write_params = WriteParams {
 			fd: STDERR_FILENO,
-			buf: GuestVirtAddr::from_ptr(buf.as_ptr()),
-			len: buf.len(),
+			buf: GuestPhysAddr::new(
+				paging::virtual_to_physical(VirtAddr::from_ptr(buf.as_ptr()))
+					.unwrap()
+					.as_u64(),
+			),
+			len: buf.len().try_into().unwrap(),
 		};
 		uhyve_hypercall(Hypercall::FileWrite(&write_params));
 
-		Ok(write_params.len)
+		Ok(write_params.len.try_into().unwrap())
 	}
 
 	async fn isatty(&self) -> io::Result<bool> {

src/fd/stdio.rs

@@ -9,10 +9,11 @@ use async_lock::Mutex;
 use async_trait::async_trait;
 use embedded_io::{ErrorType, Read, Write};
 use memory_addresses::VirtAddr;
-use uhyve_interface::parameters::{
+use uhyve_interface::GuestPhysAddr;
+use uhyve_interface::v2::Hypercall;
+use uhyve_interface::v2::parameters::{
 	CloseParams, LseekParams, OpenParams, ReadParams, UnlinkParams, WriteParams,
 };
-use uhyve_interface::{GuestPhysAddr, GuestVirtAddr, Hypercall};
 
 use crate::arch::mm::paging;
 use crate::env::fdt;
@@ -56,8 +57,12 @@ impl Read for UhyveFileHandleInner {
 	fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
 		let mut read_params = ReadParams {
 			fd: self.0,
-			buf: GuestVirtAddr::from_ptr(buf.as_mut_ptr()),
-			len: buf.len(),
+			buf: GuestPhysAddr::new(
+				paging::virtual_to_physical(VirtAddr::from_ptr(buf.as_mut_ptr()))
+					.unwrap()
+					.as_u64(),
+			),
+			len: buf.len().try_into().unwrap(),
 			ret: 0,
 		};
 		uhyve_hypercall(Hypercall::FileRead(&mut read_params));
@@ -74,12 +79,16 @@ impl Write for UhyveFileHandleInner {
 	fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
 		let write_params = WriteParams {
 			fd: self.0,
-			buf: GuestVirtAddr::from_ptr(buf.as_ptr()),
-			len: buf.len(),
+			buf: GuestPhysAddr::new(
+				paging::virtual_to_physical(VirtAddr::from_ptr(buf.as_ptr()))
+					.unwrap()
+					.as_u64(),
+			),
+			len: buf.len().try_into().unwrap(),
 		};
 		uhyve_hypercall(Hypercall::FileWrite(&write_params));
 
-		Ok(write_params.len)
+		Ok(write_params.len.try_into().unwrap())
 	}
 
 	fn flush(&mut self) -> Result<(), Self::Error> {

src/fs/uhyve.rs

@@ -1,14 +1,14 @@
 use core::ptr;
 
 use memory_addresses::VirtAddr;
-use uhyve_interface::parameters::{ExitParams, SerialWriteBufferParams};
-use uhyve_interface::{Hypercall, HypercallAddress};
+use uhyve_interface::v2::parameters::SerialWriteBufferParams;
+use uhyve_interface::v2::{Hypercall, HypercallAddress};
 
 use crate::arch;
 use crate::arch::mm::paging::{self, virtual_to_physical};
 use crate::syscalls::interfaces::SyscallInterface;
 
-/// perform a SerialWriteBuffer hypercall with `buf` as payload.
+/// perform a SerialWriteBuffer hypercall with `buf` as payload
 #[inline]
 #[cfg_attr(target_arch = "riscv64", expect(dead_code))]
 pub(crate) fn serial_buf_hypercall(buf: &[u8]) {
@@ -31,9 +31,11 @@ fn data_addr<T>(data: &T) -> u64 {
 #[inline]
 fn hypercall_data(hypercall: &Hypercall<'_>) -> u64 {
 	match hypercall {
-		Hypercall::Cmdsize(data) => data_addr(*data),
-		Hypercall::Cmdval(data) => data_addr(*data),
-		Hypercall::Exit(data) => data_addr(*data),
+		// As we are encoding an exit code (max 32 bits) into "an
+		// address", and memory_addresses complains if an address
+		// has any bits above the 48th one set to 1, we encode
+		// potential negative numbers into a u32, then a u64.
+		Hypercall::Exit(exit_code) => u64::from((*exit_code) as u32),
 		Hypercall::FileClose(data) => data_addr(*data),
 		Hypercall::FileLseek(data) => data_addr(*data),
 		Hypercall::FileOpen(data) => data_addr(*data),
@@ -55,19 +57,18 @@ pub(crate) fn uhyve_hypercall(hypercall: Hypercall<'_>) {
 
 	#[cfg(target_arch = "x86_64")]
 	unsafe {
-		use x86_64::instructions::port::Port;
-
-		let data =
-			u32::try_from(data).expect("Hypercall data must lie in the first 4GiB of memory");
-		Port::new(ptr).write(data);
+		use core::arch::asm;
+		asm!(
+			"out dx, eax", in("dx") ptr, in("eax") 0x1234u32, in("rcx") data, options(nomem, nostack, preserves_flags)
+		);
 	}
 
 	#[cfg(target_arch = "aarch64")]
 	unsafe {
 		use core::arch::asm;
 		asm!(
 			"str x8, [{ptr}]",
-			ptr = in(reg) u64::from(ptr),
+			ptr = in(reg) ptr,
 			in("x8") data,
 			options(nostack),
 		);
@@ -81,8 +82,7 @@ pub struct Uhyve;
 
 impl SyscallInterface for Uhyve {
 	fn shutdown(&self, error_code: i32) -> ! {
-		let sysexit = ExitParams { arg: error_code };
-		uhyve_hypercall(Hypercall::Exit(&sysexit));
+		uhyve_hypercall(Hypercall::Exit(error_code));
 
 		loop {
 			arch::processor::halt();