hermit/fs/

uhyve.rs

use alloc::borrow::ToOwned;
use alloc::boxed::Box;
use alloc::ffi::CString;
use alloc::string::String;
use alloc::sync::Arc;
use core::mem::MaybeUninit;

use async_lock::Mutex;
use embedded_io::{ErrorType, Read, Write};
use memory_addresses::VirtAddr;
use uhyve_interface::GuestPhysAddr;
use uhyve_interface::v2::Hypercall;
use uhyve_interface::v2::parameters::{
	CloseParams, FstatParams, GetdentParams, GetdentResult, LseekParams, OpenParams, ReadParams,
	StatKind, StatParams, StatResult, UnlinkParams, WriteParams,
};

use crate::arch::mm::paging::virtual_to_physical;
use crate::env::FdtStartInfo;
use crate::errno::Errno;
use crate::fd::{Fd, RawFd};
use crate::fs::{
	self, AccessPermission, FileAttr, NodeKind, ObjectInterface, OpenOption, SeekWhence, VfsNode,
};
use crate::syscalls::DirentFormat;
use crate::uhyve::uhyve_hypercall;
use crate::{env, io};

fn fstat_hypercall(fd: i32) -> io::Result<FileAttr> {
	let mut attr = FileAttr::default();
	let mut fstat_params = FstatParams {
		fd,
		attr: GuestPhysAddr::new(
			virtual_to_physical(VirtAddr::from_ptr((&raw mut attr).cast::<FileAttr>()))
				.unwrap()
				.as_u64(),
		),
		ret: StatResult::None,
	};
	uhyve_hypercall(Hypercall::FileFstat(&mut fstat_params));
	match fstat_params.ret {
		StatResult::None => Err(Errno::Nosys),
		StatResult::Success => Ok(attr),
		StatResult::Error(errno) => Err(Errno::try_from(errno).unwrap()),
	}
}

#[derive(Debug)]
struct UhyveFileHandleInner(i32);

impl UhyveFileHandleInner {
	pub fn new(fd: RawFd) -> Self {
		Self(fd)
	}

	fn lseek(&self, offset: isize, whence: SeekWhence) -> io::Result<isize> {
		let mut lseek_params = LseekParams {
			fd: self.0,
			offset: offset.try_into().unwrap(),
			whence: u8::from(whence).into(),
		};
		uhyve_hypercall(Hypercall::FileLseek(&mut lseek_params));
		// TODO: Although we can generally assume that what Uhyve delivers should be
		// correct for now, it might make sense to build in checks (or at least debug_assert's)
		match lseek_params.offset {
			offset if offset >= 0 => Ok(offset.try_into().unwrap()),
			errno if errno < 0 => Err((errno as i32).abs().try_into().unwrap()),
			_ => {
				debug!("Uhyve lseek hypercall yielded a zero.");
				Err(Errno::Inval)
			}
		}
	}
}

impl ErrorType for UhyveFileHandleInner {
	type Error = Errno;
}

impl Read for UhyveFileHandleInner {
	fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
		let mut read_params = ReadParams {
			fd: self.0,
			buf: GuestPhysAddr::new(
				virtual_to_physical(VirtAddr::from_ptr(buf.as_mut_ptr()))
					.unwrap()
					.as_u64(),
			),
			len: buf.len().try_into().unwrap(),
			ret: 0i64,
		};
		uhyve_hypercall(Hypercall::FileRead(&mut read_params));
		match read_params.ret {
			ret if ret >= 0 => Ok(ret.try_into().unwrap()),
			_ => Err((read_params.ret as i32).abs().try_into().unwrap()),
		}
	}
}

impl Write for UhyveFileHandleInner {
	fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
		let mut write_params = WriteParams {
			fd: self.0,
			buf: GuestPhysAddr::new(
				virtual_to_physical(VirtAddr::from_ptr(buf.as_ptr()))
					.unwrap()
					.as_u64(),
			),
			len: buf.len().try_into().unwrap(),
			ret: 0i64,
		};
		// fd refers to a regular file
		uhyve_hypercall(Hypercall::FileWrite(&mut write_params));
		match write_params.ret {
			// Assumption: fd is a regular file, a zero is only valid if the len
			// (aka. "count") is also zero. Otherwise, however, we assume that something
			// is wrong in Hermit<>Uhyve communication.
			ret if ret > 0 || (ret == 0 && write_params.len == 0) => Ok(ret.try_into().unwrap()),
			errno if errno < 0 => Err((errno as i32).abs().try_into().unwrap()),
			_ => {
				debug!("Uhyve write hypercall yielded a zero.");
				Err(Errno::Inval)
			}
		}
	}

	fn flush(&mut self) -> Result<(), Self::Error> {
		Ok(())
	}
}

impl Drop for UhyveFileHandleInner {
	fn drop(&mut self) {
		let mut close_params = CloseParams { fd: self.0, ret: 0 };
		uhyve_hypercall(Hypercall::FileClose(&mut close_params));
		if close_params.ret != 0 {
			let ret = close_params.ret; // circumvent packed field access
			panic!("Can't close fd {} - return value {ret}", self.0);
		}
	}
}

pub struct UhyveFileHandle(Arc<Mutex<UhyveFileHandleInner>>);

impl UhyveFileHandle {
	pub fn new(fd: RawFd) -> Self {
		Self(Arc::new(Mutex::new(UhyveFileHandleInner::new(fd))))
	}
}

impl ObjectInterface for UhyveFileHandle {
	async fn read(&self, buf: &mut [u8]) -> io::Result<usize> {
		self.0.lock().await.read(buf)
	}

	async fn write(&self, buf: &[u8]) -> io::Result<usize> {
		self.0.lock().await.write(buf)
	}

	async fn lseek(&self, offset: isize, whence: SeekWhence) -> io::Result<isize> {
		self.0.lock().await.lseek(offset, whence)
	}

	async fn fstat(&self) -> io::Result<FileAttr> {
		fstat_hypercall(self.0.lock().await.0)
	}
}

impl Clone for UhyveFileHandle {
	fn clone(&self) -> Self {
		Self(self.0.clone())
	}
}

pub struct UhyveDirectoryHandle {
	/// Guest fd of the directory, mapped in Uhyve's fd layer.
	fd: i32,
}

impl UhyveDirectoryHandle {
	pub const fn new(fd: i32) -> Self {
		Self { fd }
	}
}

impl Drop for UhyveDirectoryHandle {
	fn drop(&mut self) {
		let mut close_params = CloseParams {
			fd: self.fd,
			ret: 0,
		};
		uhyve_hypercall(Hypercall::FileClose(&mut close_params));
	}
}

impl ObjectInterface for UhyveDirectoryHandle {
	async fn getdents(
		&self,
		buf: &mut [MaybeUninit<u8>],
		format: DirentFormat,
	) -> io::Result<usize> {
		match format {
			DirentFormat::PosixDent => unimplemented!("Uhyve has no POSIX dirent support (yet)"),
			DirentFormat::Dirent64 => {
				let mut read_dir_params = GetdentParams {
					fd: self.fd,
					buf: GuestPhysAddr::new(
						virtual_to_physical(VirtAddr::from_ptr(buf.as_mut_ptr()))
							.unwrap()
							.as_u64(),
					),
					len: buf.len().try_into().unwrap(),
					ret: GetdentResult::None,
				};
				uhyve_hypercall(Hypercall::Getdents(&mut read_dir_params));
				match read_dir_params.ret {
					GetdentResult::None => Err(Errno::Nosys),
					GetdentResult::Success(len) => Ok(len.try_into().unwrap()),
					GetdentResult::EndOfDirectory => Ok(0),
					GetdentResult::Error(errno) => Err(Errno::try_from(errno).unwrap()),
				}
			}
		}
	}

	async fn fstat(&self) -> io::Result<FileAttr> {
		fstat_hypercall(self.fd)
	}
}

#[derive(Debug)]
pub(crate) struct UhyveDirectory {
	/// The external path of this directory.
	///
	/// Before talking to virtio-fs, the relative path inside this directory is
	/// adjoined with this prefix.
	prefix: String,
}

impl UhyveDirectory {
	pub const fn new(prefix: String) -> Self {
		UhyveDirectory { prefix }
	}

	fn traversal_path(&self, path: &str) -> CString {
		let prefix = self.prefix.as_str();
		let prefix = prefix.strip_suffix("/").unwrap_or(prefix);
		if path.is_empty() {
			return CString::new(prefix).unwrap();
		}
		let path = [prefix, path].join("/");
		CString::new(path).unwrap()
	}

	fn stat_hypercall(&self, path: &str, kind: StatKind) -> io::Result<FileAttr> {
		let path = self.traversal_path(path);
		let mut attr = FileAttr::default();
		let mut stat_params = StatParams {
			name: GuestPhysAddr::new(
				virtual_to_physical(VirtAddr::from_ptr(path.as_ptr()))
					.unwrap()
					.as_u64(),
			),
			kind,
			attr: GuestPhysAddr::new(
				virtual_to_physical(VirtAddr::from_ptr((&raw mut attr).cast::<FileAttr>()))
					.unwrap()
					.as_u64(),
			),
			ret: StatResult::None,
		};
		uhyve_hypercall(Hypercall::FileStat(&mut stat_params));
		match stat_params.ret {
			StatResult::None => Err(Errno::Nosys),
			StatResult::Success => Ok(attr),
			StatResult::Error(errno) => Err(Errno::try_from(errno).unwrap()),
		}
	}
}

impl VfsNode for UhyveDirectory {
	/// Returns the node type
	fn get_kind(&self) -> NodeKind {
		NodeKind::Directory
	}

	fn get_file_attributes(&self) -> io::Result<FileAttr> {
		self.stat_hypercall("", StatKind::Stat)
	}

	fn traverse_stat(&self, path: &str) -> io::Result<FileAttr> {
		self.stat_hypercall(path, StatKind::Stat)
	}

	fn traverse_lstat(&self, path: &str) -> io::Result<FileAttr> {
		self.stat_hypercall(path, StatKind::LStat)
	}

	fn traverse_open(
		&self,
		path: &str,
		opt: OpenOption,
		mode: AccessPermission,
	) -> io::Result<Arc<async_lock::RwLock<Fd>>> {
		let path = self.traversal_path(path);

		let mut open_params = OpenParams {
			name: GuestPhysAddr::new(
				virtual_to_physical(VirtAddr::from_ptr(path.as_ptr()))
					.unwrap()
					.as_u64(),
			),
			flags: opt.bits(),
			mode: mode.bits() as i32,
			ret: -1,
		};
		uhyve_hypercall(Hypercall::FileOpen(&mut open_params));
		let ret = open_params.ret; // circumvent packed field access
		match ret {
			// Assumption: Uhyve will never return a standard stream.
			ret if ret >= 0 => {
				let obj = if opt.contains(OpenOption::O_DIRECTORY) {
					UhyveDirectoryHandle::new(ret).into()
				} else {
					UhyveFileHandle::new(ret).into()
				};
				Ok(Arc::new(async_lock::RwLock::new(obj)))
			}
			_ => Err(ret.abs().try_into().unwrap()),
		}
	}

	fn traverse_unlink(&self, path: &str) -> io::Result<()> {
		let path = self.traversal_path(path);

		let mut unlink_params = UnlinkParams {
			name: GuestPhysAddr::new(
				virtual_to_physical(VirtAddr::from_ptr(path.as_ptr()))
					.unwrap()
					.as_u64(),
			),
			ret: -1,
		};
		uhyve_hypercall(Hypercall::FileUnlink(&mut unlink_params));
		let ret = unlink_params.ret; // circumvent packed field access
		match ret {
			0 => Ok(()),
			_ => Err(unlink_params.ret.abs().try_into().unwrap()),
		}
	}

	fn traverse_rmdir(&self, _path: &str) -> io::Result<()> {
		Err(Errno::Nosys)
	}

	fn traverse_mkdir(&self, _path: &str, _mode: AccessPermission) -> io::Result<()> {
		Err(Errno::Nosys)
	}

	/// Determines the syscall interface
	fn get_object(&self) -> io::Result<Arc<async_lock::RwLock<Fd>>> {
		let path = CString::new(self.prefix.clone()).unwrap();
		let mut open_params = OpenParams {
			name: GuestPhysAddr::new(
				virtual_to_physical(VirtAddr::from_ptr(path.as_ptr()))
					.unwrap()
					.as_u64(),
			),
			flags: (OpenOption::O_RDONLY | OpenOption::O_DIRECTORY).bits(),
			mode: 0,
			ret: -1,
		};
		uhyve_hypercall(Hypercall::FileOpen(&mut open_params));
		let fd = open_params.ret;
		match fd {
			fd if fd >= 0 => Ok(Arc::new(async_lock::RwLock::new(
				UhyveDirectoryHandle::new(fd).into(),
			))),
			_ => Err(fd.abs().try_into().unwrap()),
		}
	}
}

pub(crate) fn init() {
	info!("Try to initialize uhyve filesystem");

	let mount_str = env::start_info().fdt().and_then(|fdt| {
		fdt.find_node("/uhyve,mounts")
			.and_then(|node| node.property("mounts"))
			.and_then(|property| property.as_str())
	});

	let Some(mount_str) = mount_str else {
		// No FDT -> Uhyve legacy mounting (to /root)
		let mount_point = hermit_var_or!("UHYVE_MOUNT", "/root").to_owned();
		info!("Mounting uhyve filesystem at {mount_point}");
		fs::FILESYSTEM
			.get()
			.unwrap()
			.mount(
				&mount_point,
				Box::new(UhyveDirectory::new(mount_point.clone())),
			)
			.expect("Mount failed. Duplicate mount_point?");
		return;
	};

	assert_ne!(mount_str.len(), 0, "Invalid /uhyve,mounts node in FDT");
	for mount_point in mount_str.split('\0') {
		info!("Mounting uhyve filesystem at {mount_point}");

		let obj = Box::new(UhyveDirectory::new(mount_point.to_owned()));
		let Err(errno) = fs::FILESYSTEM.get().unwrap().mount(mount_point, obj) else {
			continue;
		};

		assert_eq!(errno, Errno::Badf);
		debug!("Mounting of {mount_point} failed with {errno:?}. Creating missing parent folders");
		let (parent_path, _file_name) = mount_point.rsplit_once('/').unwrap();
		create_dir_recursive(parent_path, AccessPermission::S_IRWXU).unwrap();

		let obj = Box::new(UhyveDirectory::new(mount_point.to_owned()));
		fs::FILESYSTEM
			.get()
			.unwrap()
			.mount(mount_point, obj)
			.unwrap();
	}
}

/// Creates a directory and creates all missing parent directories as well.
fn create_dir_recursive(path: &str, mode: AccessPermission) -> io::Result<()> {
	trace!("create_dir_recursive: {path}");
	fs::create_dir(path, mode).or_else(|errno| {
		if errno != Errno::Badf {
			return Err(errno);
		}
		let (parent_path, _file_name) = path.rsplit_once('/').unwrap();
		create_dir_recursive(parent_path, mode)?;
		fs::create_dir(path, mode)
	})
}