Uhyve: implement fstat and stat hypercall

Author: jounathaen

src/fs/uhyve.rs

@@ -11,8 +11,8 @@ use memory_addresses::VirtAddr;
 use uhyve_interface::GuestPhysAddr;
 use uhyve_interface::v2::Hypercall;
 use uhyve_interface::v2::parameters::{
-	CloseParams, GetdentParams, GetdentResult, LseekParams, OpenParams, ReadParams, UnlinkParams,
-	WriteParams,
+	CloseParams, FstatParams, GetdentParams, GetdentResult, LseekParams, OpenParams, ReadParams,
+	StatKind, StatParams, StatResult, UnlinkParams, WriteParams,
 };
 
 use crate::arch::mm::paging::virtual_to_physical;
@@ -25,6 +25,25 @@ use crate::fs::{
 use crate::io;
 use crate::uhyve::uhyve_hypercall;
 
+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);
 
@@ -140,6 +159,10 @@ impl ObjectInterface for UhyveFileHandle {
 	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 {
@@ -189,6 +212,10 @@ impl ObjectInterface for UhyveDirectoryHandle {
 			GetdentResult::Error(errno) => Err(Errno::try_from(errno).unwrap()),
 		}
 	}
+
+	async fn fstat(&self) -> io::Result<FileAttr> {
+		fstat_hypercall(self.fd)
+	}
 }
 
 #[derive(Debug)]
@@ -208,9 +235,37 @@ impl UhyveDirectory {
 	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 {
@@ -219,12 +274,16 @@ impl VfsNode for UhyveDirectory {
 		NodeKind::Directory
 	}
 
-	fn traverse_stat(&self, _path: &str) -> io::Result<FileAttr> {
-		Err(Errno::Nosys)
+	fn get_file_attributes(&self) -> io::Result<FileAttr> {
+		self.stat_hypercall("", StatKind::Stat)
 	}
 
-	fn traverse_lstat(&self, _path: &str) -> io::Result<FileAttr> {
-		Err(Errno::Nosys)
+	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(
@@ -249,9 +308,14 @@ impl VfsNode for UhyveDirectory {
 		let ret = open_params.ret; // circumvent packed field access
 		match ret {
 			// Assumption: Uhyve will never return a standard stream.
-			ret if ret >= 0 => Ok(Arc::new(async_lock::RwLock::new(
-				UhyveFileHandle::new(ret).into(),
-			))),
+			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()),
 		}
 	}

src/uhyve.rs

@@ -49,6 +49,8 @@ fn hypercall_data(hypercall: &Hypercall<'_>) -> u64 {
 		Hypercall::FileUnlink(data) => data_addr(*data),
 		Hypercall::FileWrite(data) => data_addr(*data),
 		Hypercall::Getdents(data) => data_addr(*data),
+		Hypercall::FileStat(data) => data_addr(*data),
+		Hypercall::FileFstat(data) => data_addr(*data),
 		Hypercall::SerialWriteBuffer(data) => data_addr(*data),
 		Hypercall::SerialWriteByte(byte) => u64::from(*byte),
 		h => todo!("unimplemented hypercall {h:?}"),