hermit/fs/

mod.rs

pub(crate) mod dev_directory;
pub(crate) mod mem;
#[cfg(feature = "uhyve")]
pub(crate) mod uhyve;
#[cfg(feature = "virtio-fs")]
pub(crate) mod virtio_fs;

use alloc::borrow::ToOwned;
use alloc::boxed::Box;
use alloc::string::String;
use alloc::sync::Arc;
use alloc::vec::Vec;
use core::fmt;
use core::mem::MaybeUninit;
use core::ops::BitAnd;

use embedded_io::{Read, Write};
use hermit_sync::{InterruptSpinMutex, OnceCell};
use mem::MemDirectory;
use num_enum::{IntoPrimitive, TryFromPrimitive};

use crate::errno::Errno;
use crate::executor::block_on;
use crate::fd::{AccessPermission, Fd, ObjectInterface, OpenOption, insert_object, remove_object};
use crate::io;
use crate::syscalls::DirentFormat;
use crate::time::{SystemTime, timespec};

static FILESYSTEM: OnceCell<Filesystem> = OnceCell::new();

static WORKING_DIRECTORY: InterruptSpinMutex<Option<String>> = InterruptSpinMutex::new(None);

static UMASK: InterruptSpinMutex<AccessPermission> =
	InterruptSpinMutex::new(AccessPermission::from_bits_retain(0o777));

#[derive(Debug, Clone)]
pub struct DirectoryEntry {
	pub name: String,
}

impl DirectoryEntry {
	pub fn new(name: String) -> Self {
		Self { name }
	}
}

/// Type of the VNode
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub(crate) enum NodeKind {
	/// Node represent a file
	File,
	/// Node represent a directory
	Directory,
}

/// VfsNode represents an internal node of the ramdisk.
pub(crate) trait VfsNode: Send + Sync + fmt::Debug {
	/// Determines the current node type
	fn get_kind(&self) -> NodeKind;

	/// Determines the current file attribute
	fn get_file_attributes(&self) -> io::Result<FileAttr> {
		Err(Errno::Nosys)
	}

	/// Determines the syscall interface
	fn get_object(&self) -> io::Result<Arc<async_lock::RwLock<Fd>>> {
		Err(Errno::Nosys)
	}

	/// Creates a new directory node
	fn traverse_mkdir(&self, _path: &str, _mode: AccessPermission) -> io::Result<()> {
		Err(Errno::Nosys)
	}

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

	/// Removes the specified file
	fn traverse_unlink(&self, _path: &str) -> io::Result<()> {
		Err(Errno::Nosys)
	}

	/// Opens a directory
	fn traverse_readdir(&self, _path: &str) -> io::Result<Vec<DirectoryEntry>> {
		Err(Errno::Nosys)
	}

	/// Gets file status
	fn traverse_lstat(&self, _path: &str) -> io::Result<FileAttr> {
		Err(Errno::Nosys)
	}

	/// Gets file status
	fn traverse_stat(&self, _path: &str) -> io::Result<FileAttr> {
		Err(Errno::Nosys)
	}

	/// Mounts a file system
	fn traverse_mount(&self, _path: &str, _obj: Box<dyn VfsNode>) -> io::Result<()> {
		Err(Errno::Nosys)
	}

	/// Opens a file
	fn traverse_open(
		&self,
		_path: &str,
		_option: OpenOption,
		_mode: AccessPermission,
	) -> io::Result<Arc<async_lock::RwLock<Fd>>> {
		Err(Errno::Nosys)
	}

	/// Creates a read-only file
	fn traverse_create_file(
		&self,
		_path: &str,
		_data: &'static [u8],
		_mode: AccessPermission,
	) -> io::Result<()> {
		Err(Errno::Nosys)
	}
}

pub(crate) struct DirectoryReader {
	entries: Vec<DirectoryEntry>,
	read_idx: async_lock::Mutex<usize>,
}

impl DirectoryReader {
	pub fn new(entries: Vec<DirectoryEntry>) -> Self {
		Self {
			entries,
			read_idx: async_lock::Mutex::new(0),
		}
	}
}

impl ObjectInterface for DirectoryReader {
	async fn getdents(
		&self,
		buf: &mut [MaybeUninit<u8>],
		format: DirentFormat,
	) -> io::Result<usize> {
		let mut buf_offset: usize = 0;
		let mut read_idx = self.read_idx.lock().await;
		for entry in self.entries.iter().skip(*read_idx) {
			let Some(next_dirent) =
				format.write_entry(buf, buf_offset, 1, FileType::Unknown, entry.name.as_bytes())
			else {
				if buf_offset == 0 {
					// Buffer too small to hold even one entry
					return Err(Errno::Inval);
				}
				// Buffer full -> return bytes written so far; caller retries from read_idx
				break;
			};

			*read_idx += 1;
			buf_offset = next_dirent;
		}
		Ok(buf_offset)
	}

	async fn lseek(&self, offset: isize, whence: SeekWhence) -> io::Result<isize> {
		if whence != SeekWhence::Set && offset != 0 {
			error!("Invalid offset for directory lseek ({offset})");
			return Err(Errno::Inval);
		}
		*self.read_idx.lock().await = offset as usize;
		Ok(offset)
	}
}

#[derive(Debug)]
pub(crate) struct Filesystem {
	root: MemDirectory,
}

impl Filesystem {
	pub fn new() -> Self {
		Self {
			root: MemDirectory::new(AccessPermission::from_bits(0o777).unwrap()),
		}
	}

	/// Tries to open file at given path.
	pub fn open(
		&self,
		path: &str,
		opt: OpenOption,
		mode: AccessPermission,
	) -> io::Result<Arc<async_lock::RwLock<Fd>>> {
		debug!("Open file {path} with {opt:?}");

		let path = path.strip_prefix('/').unwrap_or(path);

		self.root.traverse_open(path, opt, mode)
	}

	/// Unlinks a file given by path
	pub fn unlink(&self, path: &str) -> io::Result<()> {
		debug!("Unlinking file {path}");

		let path = path.strip_prefix('/').unwrap_or(path);

		self.root.traverse_unlink(path)
	}

	/// Remove directory given by path
	pub fn rmdir(&self, path: &str) -> io::Result<()> {
		debug!("Removing directory {path}");

		let path = path.strip_prefix('/').unwrap_or(path);

		self.root.traverse_rmdir(path)
	}

	/// Create directory given by path
	pub fn mkdir(&self, path: &str, mode: AccessPermission) -> io::Result<()> {
		debug!("Create directory {path}");

		let path = path.strip_prefix('/').unwrap_or(path);

		self.root.traverse_mkdir(path, mode)
	}

	pub fn opendir(&self, path: &str) -> io::Result<Arc<async_lock::RwLock<Fd>>> {
		debug!("Open directory {path}");
		Ok(Arc::new(async_lock::RwLock::new(
			DirectoryReader::new(self.readdir(path)?).into(),
		)))
	}

	/// List given directory
	pub fn readdir(&self, path: &str) -> io::Result<Vec<DirectoryEntry>> {
		debug!("Readdir {path}");

		let path = path.strip_prefix('/').unwrap_or(path);

		self.root.traverse_readdir(path)
	}

	/// stat
	pub fn stat(&self, path: &str) -> io::Result<FileAttr> {
		debug!("Getting stats {path}");

		let path = path.strip_prefix('/').unwrap_or(path);

		self.root.traverse_stat(path)
	}

	/// lstat
	pub fn lstat(&self, path: &str) -> io::Result<FileAttr> {
		debug!("Getting lstats {path}");

		let path = path.strip_prefix('/').unwrap_or(path);

		self.root.traverse_lstat(path)
	}

	/// Create new backing-fs at mountpoint mntpath
	pub fn mount(&self, path: &str, obj: Box<dyn VfsNode>) -> io::Result<()> {
		debug!("Mounting {path}");

		let path = path.strip_prefix('/').unwrap_or(path);

		self.root.traverse_mount(path, obj)
	}

	/// Create read-only file
	pub fn create_file(
		&self,
		path: &str,
		data: &'static [u8],
		mode: AccessPermission,
	) -> io::Result<()> {
		debug!("Create read-only file {path}");

		let path = path.strip_prefix('/').unwrap_or(path);

		self.root.traverse_create_file(path, data, mode)
	}
}

#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct FileAttr {
	pub st_dev: u64,
	pub st_ino: u64,
	pub st_nlink: u64,
	/// Access permissions
	pub st_mode: AccessPermission,
	/// User id
	pub st_uid: u32,
	/// Group id
	pub st_gid: u32,
	/// Device id
	pub st_rdev: u64,
	/// Size in bytes
	pub st_size: i64,
	/// Block size
	pub st_blksize: i64,
	/// Size in blocks
	pub st_blocks: i64,
	/// Time of last access
	pub st_atim: timespec,
	/// Time of last modification
	pub st_mtim: timespec,
	/// Time of last status change
	pub st_ctim: timespec,
}

#[derive(TryFromPrimitive, IntoPrimitive, PartialEq, Eq, Clone, Copy, Debug)]
#[repr(u8)]
pub enum FileType {
	Unknown = 0,         // DT_UNKNOWN
	Fifo = 1,            // DT_FIFO
	CharacterDevice = 2, // DT_CHR
	Directory = 4,       // DT_DIR
	BlockDevice = 6,     // DT_BLK
	RegularFile = 8,     // DT_REG
	SymbolicLink = 10,   // DT_LNK
	Socket = 12,         // DT_SOCK
	Whiteout = 14,       // DT_WHT
}

#[derive(TryFromPrimitive, IntoPrimitive, PartialEq, Eq, Clone, Copy, Debug)]
#[repr(u8)]
pub enum SeekWhence {
	Set = 0,
	Cur = 1,
	End = 2,
	Data = 3,
	Hole = 4,
}

pub(crate) fn init() {
	const VERSION: &str = env!("CARGO_PKG_VERSION");
	const UTC_BUILT_TIME: &str = build_time::build_time_utc!();

	let root_filesystem = Filesystem::new();

	root_filesystem
		.mkdir("/tmp", AccessPermission::from_bits(0o777).unwrap())
		.expect("Unable to create /tmp");
	root_filesystem
		.mkdir("/proc", AccessPermission::from_bits(0o777).unwrap())
		.expect("Unable to create /proc");

	FILESYSTEM.set(root_filesystem).unwrap();

	if let Ok(mut file) = File::create("/proc/version") {
		if write!(file, "Hermit version {VERSION} # UTC {UTC_BUILT_TIME}").is_err() {
			error!("Unable to write in /proc/version");
		}
	} else {
		error!("Unable to create /proc/version");
	}

	*WORKING_DIRECTORY.lock() = Some("/tmp".to_owned());

	#[cfg(feature = "virtio-fs")]
	virtio_fs::init();

	#[cfg(feature = "uhyve")]
	use crate::env::UhyveStartInfo;

	#[cfg(feature = "uhyve")]
	if crate::env::start_info().is_uhyve() {
		uhyve::init();
	}

	dev_directory::init();
}

pub fn create_file(name: &str, data: &'static [u8], mode: AccessPermission) -> io::Result<()> {
	with_relative_filename(name, |name| {
		FILESYSTEM
			.get()
			.ok_or(Errno::Inval)?
			.create_file(name, data, mode)
	})
}

/// Removes an empty directory.
pub fn remove_dir(path: &str) -> io::Result<()> {
	with_relative_filename(path, |path| {
		FILESYSTEM.get().ok_or(Errno::Inval)?.rmdir(path)
	})
}

pub fn unlink(path: &str) -> io::Result<()> {
	with_relative_filename(path, |path| {
		FILESYSTEM.get().ok_or(Errno::Inval)?.unlink(path)
	})
}

/// Creates a new, empty directory at the provided path
pub fn create_dir(path: &str, mode: AccessPermission) -> io::Result<()> {
	let mask = *UMASK.lock();

	with_relative_filename(path, |path| {
		FILESYSTEM
			.get()
			.ok_or(Errno::Inval)?
			.mkdir(path, mode.bitand(mask))
	})
}

/// Returns an vector with all the entries within a directory.
pub fn readdir(name: &str) -> io::Result<Vec<DirectoryEntry>> {
	debug!("Read directory {name}");

	with_relative_filename(name, |name| {
		FILESYSTEM.get().ok_or(Errno::Inval)?.readdir(name)
	})
}

pub fn read_stat(name: &str) -> io::Result<FileAttr> {
	with_relative_filename(name, |name| {
		FILESYSTEM.get().ok_or(Errno::Inval)?.stat(name)
	})
}

pub fn read_lstat(name: &str) -> io::Result<FileAttr> {
	with_relative_filename(name, |name| {
		FILESYSTEM.get().ok_or(Errno::Inval)?.lstat(name)
	})
}

fn with_relative_filename<F, T>(name: &str, callback: F) -> io::Result<T>
where
	F: FnOnce(&str) -> io::Result<T>,
{
	if name.starts_with("/") {
		return callback(name);
	}

	let cwd = WORKING_DIRECTORY.lock();

	let Some(cwd) = cwd.as_ref() else {
		// Relative path with no CWD, this is weird/impossible
		return Err(Errno::Badf);
	};

	let mut path = String::with_capacity(cwd.len() + name.len() + 1);
	path.push_str(cwd);
	path.push('/');
	path.push_str(name);

	callback(&path)
}

pub fn truncate(name: &str, size: usize) -> io::Result<()> {
	with_relative_filename(name, |name| {
		let fs = FILESYSTEM.get().ok_or(Errno::Inval)?;
		let file = fs
			.open(name, OpenOption::O_TRUNC, AccessPermission::empty())
			.map_err(|_| Errno::Badf)?;

		block_on(async { file.read().await.truncate(size).await }, None)
	})
}

pub fn open(name: &str, flags: OpenOption, mode: AccessPermission) -> io::Result<RawFd> {
	// mode is 0x777 (0b0111_0111_0111), when flags | O_CREAT, else 0
	// flags is bitmask of O_DEC_* defined above.
	// (taken from rust stdlib/sys hermit target )
	let mask = *UMASK.lock();

	with_relative_filename(name, |name| {
		debug!("Open {name}, {flags:?}, {mode:?}");

		let fs = FILESYSTEM.get().ok_or(Errno::Inval)?;
		let file = fs.open(name, flags, mode.bitand(mask))?;
		let fd = insert_object(file)?;
		Ok(fd)
	})
}

pub fn get_cwd() -> io::Result<String> {
	let cwd = WORKING_DIRECTORY.lock();
	let cwd = cwd.as_ref().ok_or(Errno::Noent)?;
	Ok(cwd.clone())
}

pub fn set_cwd(cwd: &str) -> io::Result<()> {
	// TODO: check that the directory exists and that permission flags are correct

	let mut working_dir = WORKING_DIRECTORY.lock();
	if cwd.starts_with("/") {
		*working_dir = Some(cwd.to_owned());
	} else {
		let working_dir = working_dir.as_mut().ok_or(Errno::Badf)?;
		working_dir.push('/');
		working_dir.push_str(cwd);
	}

	Ok(())
}

pub fn umask(new_mask: AccessPermission) -> AccessPermission {
	let mut lock = UMASK.lock();
	let old = *lock;
	*lock = new_mask;
	old
}

/// Open a directory to read the directory entries
pub(crate) fn opendir(name: &str) -> io::Result<RawFd> {
	let obj = FILESYSTEM.get().ok_or(Errno::Inval)?.opendir(name)?;
	insert_object(obj)
}

use crate::fd::{self, RawFd};

pub fn file_attributes(path: &str) -> io::Result<FileAttr> {
	FILESYSTEM.get().ok_or(Errno::Inval)?.lstat(path)
}

#[allow(clippy::len_without_is_empty)]
#[derive(Debug, Copy, Clone)]
pub struct Metadata(FileAttr);

impl Metadata {
	/// Returns the size of the file, in bytes
	pub fn len(&self) -> usize {
		self.0.st_size.try_into().unwrap()
	}

	/// Returns true if this metadata is for a file.
	pub fn is_file(&self) -> bool {
		self.0.st_mode.contains(AccessPermission::S_IFREG)
	}

	/// Returns true if this metadata is for a directory.
	pub fn is_dir(&self) -> bool {
		self.0.st_mode.contains(AccessPermission::S_IFDIR)
	}

	/// Returns the last modification time listed in this metadata.
	pub fn modified(&self) -> io::Result<SystemTime> {
		Ok(SystemTime::from(self.0.st_mtim))
	}

	/// Returns the last modification time listed in this metadata.
	pub fn accessed(&self) -> io::Result<SystemTime> {
		Ok(SystemTime::from(self.0.st_atim))
	}
}

/// Given a path, query the file system to get information about a file, directory, etc.
pub fn metadata(path: &str) -> io::Result<Metadata> {
	Ok(Metadata(file_attributes(path)?))
}

#[derive(Debug)]
pub struct File {
	fd: RawFd,
	path: String,
}

impl File {
	/// Opens a file in write-only mode.
	///
	/// This function will create a file if it does not exist, and will truncate it if it does.
	fn create(path: &str) -> io::Result<File> {
		let fd = open(
			path,
			OpenOption::O_CREAT | OpenOption::O_TRUNC | OpenOption::O_WRONLY,
			AccessPermission::from_bits(0o666).unwrap(),
		)?;

		Ok(File {
			fd,
			path: path.to_owned(),
		})
	}

	/// Creates a new file in read-write mode; error if the file exists.
	///
	/// This function will create a file if it does not exist, or return
	/// an error if it does. This way, if the call succeeds, the file
	/// returned is guaranteed to be new.
	pub fn create_new(path: &str) -> io::Result<Self> {
		let fd = open(
			path,
			OpenOption::O_CREAT | OpenOption::O_EXCL | OpenOption::O_RDWR,
			AccessPermission::from_bits(0o666).unwrap(),
		)?;

		Ok(File {
			fd,
			path: path.to_owned(),
		})
	}

	/// Attempts to open a file in read-write mode.
	pub fn open(path: &str) -> io::Result<Self> {
		let fd = open(
			path,
			OpenOption::O_RDWR,
			AccessPermission::from_bits(0o666).unwrap(),
		)?;

		Ok(File {
			fd,
			path: path.to_owned(),
		})
	}

	pub fn metadata(&self) -> io::Result<Metadata> {
		metadata(&self.path)
	}
}

impl embedded_io::ErrorType for File {
	type Error = Errno;
}

impl Read for File {
	fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
		fd::read(self.fd, buf)
	}
}

impl Write for File {
	fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
		fd::write(self.fd, buf)
	}

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

impl Drop for File {
	fn drop(&mut self) {
		if let Err(err) = remove_object(self.fd) {
			error!("File::drop failed: {err}");
		}
	}
}