Extend the FUSE support

src/errno.rs

@@ -1,3 +1,6 @@
+#[thread_local]
+pub static mut ERRNO: i32 = 0;
+
 /// Operation not permitted
 pub const EPERM: i32 = 1;
 

src/fd/file.rs

@@ -1,11 +1,12 @@
 use alloc::boxed::Box;
 use core::{isize, slice};
 
+use crate::errno::*;
 use crate::fd::{
 	uhyve_send, ObjectInterface, SysClose, SysLseek, SysRead, SysWrite, UHYVE_PORT_CLOSE,
 	UHYVE_PORT_LSEEK, UHYVE_PORT_READ, UHYVE_PORT_WRITE,
 };
-use crate::syscalls::fs::{self, PosixFile, SeekWhence};
+use crate::syscalls::fs::{self, Dirent, FileAttr, PosixFile, SeekWhence};
 
 #[derive(Debug, Clone)]
 pub struct UhyveFile(i32);
@@ -98,6 +99,35 @@ impl ObjectInterface for GenericFile {
 
 		ret as isize
 	}
+
+	/// `fstat`
+	fn fstat(&self, stat: *mut FileAttr) -> i32 {
+		debug!("fstat ! {}", self.0);
+		let mut result = 0;
+		let mut fs = fs::FILESYSTEM.lock();
+		fs.fd_op(self.0, |file: &mut Box<dyn PosixFile + Send>| {
+			result = file
+				.fstat(stat)
+				.map_or_else(|e| -num::ToPrimitive::to_i32(&e).unwrap(), |_| 0);
+		});
+
+		result
+	}
+
+	fn readdir(&self) -> *const Dirent {
+		debug!("readdir ! {}", self.0);
+
+		let mut fs = fs::FILESYSTEM.lock();
+		let mut ret: *const Dirent = core::ptr::null();
+		fs.fd_op(self.0, |file: &mut Box<dyn PosixFile + Send>| {
+			match file.readdir() {
+				Ok(dir_ptr) => ret = dir_ptr,
+				Err(e) => unsafe { ERRNO = num::ToPrimitive::to_i32(&e).unwrap() },
+			}
+		});
+
+		ret
+	}
 }
 
 impl Drop for GenericFile {

src/fd/mod.rs

@@ -13,7 +13,7 @@ use crate::env;
 use crate::errno::*;
 use crate::fd::file::{GenericFile, UhyveFile};
 use crate::fd::stdio::*;
-use crate::syscalls::fs::{self, FilePerms, SeekWhence};
+use crate::syscalls::fs::{self, Dirent, FileAttr, FilePerms, SeekWhence};
 #[cfg(all(feature = "tcp", not(feature = "newlib")))]
 use crate::syscalls::net::*;
 
@@ -199,11 +199,36 @@ pub trait ObjectInterface: Sync + Send + core::fmt::Debug + DynClone {
 		(-EINVAL).try_into().unwrap()
 	}
 
-	/// `unlink` removes directory entry
+	/// `fstat`
+	fn fstat(&self, _stat: *mut FileAttr) -> i32 {
+		-EINVAL
+	}
+
+	/// `unlink` removes file entry
 	fn unlink(&self, _name: *const u8) -> i32 {
 		-EINVAL
 	}
 
+	/// `rmdir` removes directory entry
+	fn rmdir(&self, _name: *const u8) -> i32 {
+		-EINVAL
+	}
+
+	/// 'readdir' returns a pointer to a dirent structure
+	/// representing the next directory entry in the directory stream
+	/// pointed to by the file descriptor
+	fn readdir(&self) -> *const Dirent {
+		unsafe {
+			ERRNO = ENOSYS;
+		}
+		core::ptr::null()
+	}
+
+	/// `mkdir` creates a directory entry
+	fn mkdir(&self, _name: *const u8, _mode: u32) -> i32 {
+		-EINVAL
+	}
+
 	/// `accept` a connection on a socket
 	#[cfg(all(feature = "tcp", not(feature = "newlib")))]
 	fn accept(&self, _addr: *mut sockaddr, _addrlen: *mut socklen_t) -> i32 {
@@ -319,6 +344,36 @@ pub(crate) fn open(name: *const u8, flags: i32, mode: i32) -> Result<FileDescrip
 	}
 }
 
+pub(crate) fn opendir(name: *const u8) -> Result<FileDescriptor, i32> {
+	if env::is_uhyve() {
+		Err(-EINVAL)
+	} else {
+		#[cfg(target_arch = "x86_64")]
+		{
+			let name = unsafe { CStr::from_ptr(name as _) }.to_str().unwrap();
+			debug!("Open directory {}", name);
+
+			let mut fs = fs::FILESYSTEM.lock();
+			if let Ok(filesystem_fd) = fs.opendir(name) {
+				let fd = FD_COUNTER.fetch_add(1, Ordering::SeqCst);
+				// Would a GenericDir make sense?
+				let file = GenericFile::new(filesystem_fd);
+				if OBJECT_MAP.write().try_insert(fd, Arc::new(file)).is_err() {
+					Err(-EINVAL)
+				} else {
+					Ok(fd as FileDescriptor)
+				}
+			} else {
+				Err(-EINVAL)
+			}
+		}
+		#[cfg(not(target_arch = "x86_64"))]
+		{
+			Err(-ENOSYS)
+		}
+	}
+}
+
 pub(crate) fn get_object(fd: FileDescriptor) -> Result<Arc<dyn ObjectInterface>, i32> {
 	Ok((*(OBJECT_MAP.read().get(&fd).ok_or(-EINVAL)?)).clone())
 }