From 14bd17111289f4ebd8fa579150e073470dd5e73a Mon Sep 17 00:00:00 2001 From: Jonathan Klimt Date: Fri, 6 Jan 2023 13:39:10 +0100 Subject: [PATCH] Renamed IOPort in uhyve interface to HypercallAddress, to make it generic for non x86 architectures --- src/linux/vcpu.rs | 2 +- src/macos/aarch64/vcpu.rs | 3 ++- src/macos/x86_64/vcpu.rs | 2 +- src/vm.rs | 29 +++++++++++++++-------------- uhyve-interface/src/lib.rs | 8 +++----- 5 files changed, 22 insertions(+), 22 deletions(-) diff --git a/src/linux/vcpu.rs b/src/linux/vcpu.rs index 886d294a..773aabc9 100755 --- a/src/linux/vcpu.rs +++ b/src/linux/vcpu.rs @@ -362,7 +362,7 @@ impl VirtualCPU for UhyveCPU { }, VcpuExit::IoOut(port, addr) => { let data_addr: usize = unsafe { (*(addr.as_ptr() as *const u32)) as usize }; - if let Some(hypercall) = self.port_to_hypercall(port, data_addr) { + if let Some(hypercall) = self.address_to_hypercall(port, data_addr) { match hypercall { Hypercall::Cmdsize(syssize) => self.cmdsize(syssize), Hypercall::Cmdval(syscmdval) => self.cmdval(syscmdval), diff --git a/src/macos/aarch64/vcpu.rs b/src/macos/aarch64/vcpu.rs index a1c880bf..ea979b84 100644 --- a/src/macos/aarch64/vcpu.rs +++ b/src/macos/aarch64/vcpu.rs @@ -178,7 +178,8 @@ impl VirtualCPU for UhyveCPU { let pc = self.vcpu.read_register(Register::PC)?; let data_addr = self.vcpu.read_register(Register::X8)?; - if let Some(hypercall) = self.port_to_hypercall(addr, data_addr as usize) { + if let Some(hypercall) = self.address_to_hypercall(addr, data_addr as usize) + { match hypercall { Hypercall::SerialWrite(_buf) => { let x8 = (self.vcpu.read_register(Register::X8)? & 0xFF) as u8; diff --git a/src/macos/x86_64/vcpu.rs b/src/macos/x86_64/vcpu.rs index 9b132a9c..c66cc060 100644 --- a/src/macos/x86_64/vcpu.rs +++ b/src/macos/x86_64/vcpu.rs @@ -746,7 +746,7 @@ impl VirtualCPU for UhyveCPU { assert!(!input, "Invalid I/O operation"); let data_addr: u64 = self.vcpu.read_register(&Register::RAX)? & 0xFFFFFFFF; - if let Some(hypercall) = self.port_to_hypercall(port, data_addr as usize) { + if let Some(hypercall) = self.address_to_hypercall(port, data_addr as usize) { match hypercall { Hypercall::Cmdsize(syssize) => self.cmdsize(syssize), Hypercall::Cmdval(syscmdval) => self.cmdval(syscmdval), diff --git a/src/vm.rs b/src/vm.rs index 11628dac..7ead2d77 100644 --- a/src/vm.rs +++ b/src/vm.rs @@ -9,7 +9,7 @@ use hermit_entry::{ }; use log::{error, warn}; use thiserror::Error; -use uhyve_interface::{parameters::*, Hypercall, IoPorts, MAX_ARGC_ENVC}; +use uhyve_interface::{parameters::*, Hypercall, HypercallAddress, MAX_ARGC_ENVC}; #[cfg(target_arch = "x86_64")] use crate::arch::x86_64::{ @@ -72,56 +72,56 @@ pub trait VirtualCPU { fn args(&self) -> &[OsString]; /// addr is the address of the hypercall parameter in the guest's memory space. - fn port_to_hypercall(&self, port: u16, data_addr: usize) -> Option> { - if let Ok(hypercall_port) = IoPorts::try_from(port) { + fn address_to_hypercall(&self, addr: u16, data_addr: usize) -> Option> { + if let Ok(hypercall_port) = HypercallAddress::try_from(addr) { Some(match hypercall_port { - IoPorts::FileClose => { + HypercallAddress::FileClose => { let sysclose = unsafe { &mut *(self.host_address(data_addr) as *mut CloseParams) }; Hypercall::FileClose(sysclose) } - IoPorts::FileLseek => { + HypercallAddress::FileLseek => { let syslseek = unsafe { &mut *(self.host_address(data_addr) as *mut LseekParams) }; Hypercall::FileLseek(syslseek) } - IoPorts::FileOpen => { + HypercallAddress::FileOpen => { let sysopen = unsafe { &mut *(self.host_address(data_addr) as *mut OpenParams) }; Hypercall::FileOpen(sysopen) } - IoPorts::FileRead => { + HypercallAddress::FileRead => { let sysread = unsafe { &mut *(self.host_address(data_addr) as *mut ReadPrams) }; Hypercall::FileRead(sysread) } - IoPorts::FileWrite => { + HypercallAddress::FileWrite => { let syswrite = unsafe { &*(self.host_address(data_addr) as *const WriteParams) }; Hypercall::FileWrite(syswrite) } - IoPorts::FileUnlink => { + HypercallAddress::FileUnlink => { let sysunlink = unsafe { &mut *(self.host_address(data_addr) as *mut UnlinkParams) }; Hypercall::FileUnlink(sysunlink) } - IoPorts::Exit => { + HypercallAddress::Exit => { let sysexit = unsafe { &*(self.host_address(data_addr) as *const ExitParams) }; Hypercall::Exit(sysexit) } //HypercallPorts::Netwrite => {} //HypercallPorts::Netread => {} //HypercallPorts::Netstat => {} - IoPorts::Cmdsize => { + HypercallAddress::Cmdsize => { let syssize = unsafe { &mut *(self.host_address(data_addr) as *mut CmdsizeParams) }; Hypercall::Cmdsize(syssize) } - IoPorts::Cmdval => { + HypercallAddress::Cmdval => { let syscmdval = unsafe { &*(self.host_address(data_addr) as *const CmdvalParams) }; Hypercall::Cmdval(syscmdval) } - IoPorts::Uart => { + HypercallAddress::Uart => { let buf = unsafe { &*(self.host_address(data_addr) as *const &[u8]) }; Hypercall::SerialWrite(buf) } @@ -353,7 +353,8 @@ pub trait Vm { hardware_info: HardwareInfo { phys_addr_range: arch::RAM_START..arch::RAM_START + vm_mem_len as u64, serial_port_base: self.verbose().then(|| { - SerialPortBase::new((uhyve_interface::IoPorts::Uart as u16).into()).unwrap() + SerialPortBase::new((uhyve_interface::HypercallAddress::Uart as u16).into()) + .unwrap() }), }, load_info, diff --git a/uhyve-interface/src/lib.rs b/uhyve-interface/src/lib.rs index bbc5fc94..10543c77 100644 --- a/uhyve-interface/src/lib.rs +++ b/uhyve-interface/src/lib.rs @@ -7,8 +7,6 @@ //! that port is the physical memory address (of the VM) of the parameters of that hypercall. //! - On `aarch64` you write to the respective [`HypercallAddress`]. The 64-bit value written to that location is the guest's physical memory address of the hypercall's parameter. -// TODO: only x86 allows io instructions. Other architectures should use MMIO - #![no_std] // TODO: Throw this out, once https://github.com/rust-lang/rfcs/issues/2783 is resolved @@ -29,7 +27,7 @@ pub const UHYVE_INTERFACE_VERSION: u32 = 1; #[non_exhaustive] #[repr(u16)] #[derive(Debug, Eq, PartialEq, TryFromPrimitive)] -pub enum IoPorts { +pub enum HypercallAddress { /// Port address = `0x400` FileWrite = 0x400, /// Port address = `0x440` @@ -60,7 +58,7 @@ pub enum IoPorts { /// Port address = `0x840` FileUnlink = 0x840, } -impl From> for IoPorts { +impl From> for HypercallAddress { fn from(value: Hypercall) -> Self { match value { Hypercall::Cmdsize(_) => Self::Cmdsize, @@ -101,7 +99,7 @@ pub enum Hypercall<'a> { impl<'a> Hypercall<'a> { /// Get a hypercall's port address. pub fn port(self) -> u16 { - IoPorts::from(self) as u16 + HypercallAddress::from(self) as u16 } }