Filesystem: Announce mounts in FDT

Author: jounathaen

src/fdt.rs

@@ -70,6 +70,15 @@ impl Fdt {
 		Ok(self)
 	}
 
+	/// Adds a `/uhyve,mounts` node to the FDT.
+	pub fn mounts(mut self, dirs: Vec<String>) -> FdtWriterResult<Self> {
+		let mounts_node = self.writer.begin_node("uhyve,mounts")?;
+		self.writer.property_string_list("mounts", dirs)?;
+		self.writer.end_node(mounts_node)?;
+
+		Ok(self)
+	}
+
 	#[cfg(target_arch = "aarch64")]
 	fn cpu(&mut self, id: u32) -> FdtWriterResult<()> {
 		let node_name = format!("cpu@{id}");

src/isolation/filemap.rs

@@ -1,11 +1,9 @@
-#[cfg(target_os = "linux")]
-use std::path::Path;
 use std::{
 	collections::HashMap,
 	ffi::{CStr, CString, OsStr, OsString},
-	fs::canonicalize,
+	fs::{canonicalize, metadata},
 	os::unix::ffi::OsStrExt,
-	path::PathBuf,
+	path::{Path, PathBuf},
 };
 
 use clean_path::clean;
@@ -96,6 +94,38 @@ impl UhyveFileMap {
 		self.files.values().map(|i| i.as_os_str())
 	}
 
+	/// Returns an iterator (non-unique) over all mountable guest directories.
+	pub(crate) fn get_all_guest_dirs(&self) -> impl Iterator<Item = &Path> {
+		self.files.iter().filter_map(|(gp, hp)| {
+			// We check the host_path filetype, and return the parent directory for everything non-file.
+			if let Ok(hp_metadata) = metadata(hp) {
+				if hp_metadata.is_dir() {
+					Some(gp.as_path())
+				} else if hp_metadata.is_file() {
+					Some(gp.as_path().parent().unwrap())
+				} else if hp_metadata.is_symlink() {
+					error!(
+						"{} is a symlink. This is not supported (yet?)",
+						hp.display()
+					);
+					None
+				} else {
+					Some(gp.as_path().parent().unwrap())
+				}
+			} else if let Some(parent_path) = hp.parent()
+				&& let Ok(parent_metadata) = metadata(parent_path)
+				&& parent_metadata.is_dir()
+			{
+				// Parent directory exists, so this is a mounted file
+				Some(gp.as_path().parent().unwrap())
+			} else {
+				error!("{} isn't a valid host path", hp.display());
+				// return Err(ErrorKind::InvalidFilename);
+				None
+			}
+		})
+	}
+
 	/// Returns the path to the temporary directory (for Landlock).
 	#[cfg(target_os = "linux")]
 	pub(crate) fn get_temp_dir(&self) -> &Path {

src/vm.rs

@@ -208,6 +208,13 @@ impl<VirtBackend: VirtualizationBackend> UhyveVm<VirtBackend> {
 			&params.file_mapping,
 			params.tempdir.clone(),
 		));
+		let mut mounts: Vec<_> = file_mapping
+			.lock()
+			.unwrap()
+			.get_all_guest_dirs()
+			.map(|s| s.to_str().unwrap().to_string())
+			.collect();
+		mounts.dedup();
 
 		let serial = UhyveSerial::from_params(&params.output)?;
 
@@ -279,7 +286,7 @@ impl<VirtBackend: VirtualizationBackend> UhyveVm<VirtBackend> {
 
 		let freq = vcpus[0].get_cpu_frequency();
 
-		write_fdt_into_mem(&peripherals.mem, &kernel_info.params, freq);
+		write_fdt_into_mem(&peripherals.mem, &kernel_info.params, freq, mounts);
 		write_boot_info_to_mem(&peripherals.mem, load_info, cpu_count as u64, freq);
 
 		let legacy_mapping = if let Some(version) = hermit_version {
@@ -445,7 +452,12 @@ fn init_guest_mem(
 	crate::arch::init_guest_mem(mem, guest_addr, memory_size, legacy_mapping);
 }
 
-fn write_fdt_into_mem(mem: &MmapMemory, params: &Params, cpu_freq: Option<NonZeroU32>) {
+fn write_fdt_into_mem(
+	mem: &MmapMemory,
+	params: &Params,
+	cpu_freq: Option<NonZeroU32>,
+	mounts: Vec<String>,
+) {
 	trace!("Writing FDT in memory");
 
 	let sep = params
@@ -468,6 +480,10 @@ fn write_fdt_into_mem(mem: &MmapMemory, params: &Params, cpu_freq: Option<NonZer
 		EnvVars::Set(map) => fdt.envs(map.iter().map(|(a, b)| (a.as_str(), b.as_str()))),
 	};
 
+	if !mounts.is_empty() {
+		fdt = fdt.mounts(mounts).unwrap();
+	}
+
 	#[cfg(target_arch = "aarch64")]
 	{
 		fdt = fdt.gic().unwrap();

tests/data/fixtures/fs/testdir1/testfile_a.txt

@@ -0,0 +1 @@
+12345

tests/data/fixtures/fs/testdir2/testfile_b.txt

@@ -0,0 +1 @@
+abcde

tests/data/fixtures/fs/testdir3/testfile_c.txt

@@ -0,0 +1 @@
+a1b2c3

tests/fs-test.rs

@@ -12,6 +12,7 @@ use common::{
 	build_hermit_bin, check_result, get_fs_fixture_path, remove_file_if_exists, run_vm_in_thread,
 };
 use rand::{Rng, distr::Alphanumeric};
+use tempfile::TempDir;
 use uhyvelib::{params::Params, vm::UhyveVm};
 
 /// Verifies successful file creation on the host OS and its contents.
@@ -39,13 +40,35 @@ impl AsStr for &str {
 
 /// Gets a "base" guest and host path, only useful for UhyveFileMap tests.
 fn get_default_paths() -> (PathBuf, PathBuf) {
-	let guest_dir_path: PathBuf = PathBuf::from("/root/");
+	let guest_dir_path: PathBuf = PathBuf::from("/uhyve_mount");
 	let mut host_dir_path = get_fs_fixture_path();
 	host_dir_path.push("ignore_everything_here");
 
 	(guest_dir_path, host_dir_path)
 }
 
+/// Creates a temporary directory for a uhyve mount and returns the path to it
+/// as well as the owning TempDir
+fn create_tmp_mount() -> (PathBuf, TempDir) {
+	let tempdir = TempDir::new().unwrap();
+	let host_path = tempdir.path().to_path_buf();
+	(host_path, tempdir)
+}
+
+/// creates a tempfile from the given filename and returns a filemap, the guest
+/// filepath and a directory handle to the tempdir.
+fn create_filemap(guest_filename: &str) -> (Vec<String>, PathBuf, TempDir) {
+	let guest_file_path = get_testname_derived_guest_path(guest_filename);
+	let (mut host_path, tmpdir) = create_tmp_mount();
+	host_path.push(guest_filename);
+	let filemap_str = format!(
+		"{}:{}",
+		host_path.as_os_str().display(),
+		guest_file_path.as_os_str().display()
+	);
+	(vec![filemap_str], guest_file_path, tmpdir)
+}
+
 /// Generates a filename in the format of prefixab1cD23.txt
 fn generate_filename(prefix: &str) -> String {
 	let mut filename = prefix.to_owned();
@@ -64,7 +87,7 @@ fn generate_filename(prefix: &str) -> String {
 /// * `test_name` - Name of the test.
 fn get_testname_derived_guest_path(test_name: &str) -> PathBuf {
 	// Starting off with the "guest_dir_path".
-	let mut guest_file_path = PathBuf::from("/root/");
+	let mut guest_file_path = PathBuf::from("/uhyve_mount/");
 	guest_file_path.push(generate_filename(test_name));
 	guest_file_path
 }
@@ -272,8 +295,8 @@ fn fd_open_remove_close() {
 	env_logger::try_init().ok();
 
 	let test_name: &'static str = "fd_open_remove_close";
-	let guest_file_path = get_testname_derived_guest_path(test_name);
-	let params = generate_params(None, test_name, &guest_file_path);
+	let (filemap, guest_file_path, _tmpdir) = create_filemap(test_name);
+	let params = generate_params(Some(filemap), test_name, &guest_file_path);
 
 	let bin_path: PathBuf = build_hermit_bin("fs_tests");
 	let res = run_vm_in_thread(bin_path, params);
@@ -317,8 +340,8 @@ fn open_read_only_write() {
 	env_logger::try_init().ok();
 
 	let test_name: &'static str = "open_read_only_write";
-	let guest_file_path = get_testname_derived_guest_path(test_name);
-	let params = generate_params(None, test_name, &guest_file_path);
+	let (filemap, guest_file_path, _tmpdir) = create_filemap(test_name);
+	let params = generate_params(Some(filemap), test_name, &guest_file_path);
 
 	let bin_path: PathBuf = build_hermit_bin("fs_tests");
 
@@ -356,13 +379,55 @@ fn fd_write_to_fd() {
 	check_result(&res);
 }
 
+#[test]
+fn mounts_test() {
+	env_logger::try_init().ok();
+
+	let test_name: &'static str = "mounts_test";
+	let guest_dir_path: PathBuf = PathBuf::from("/");
+	let host_dir_path = get_fs_fixture_path();
+
+	let uhyvefilemap_params = vec![
+		format!(
+			"{}/testdir1:{}testdir1",
+			(&host_dir_path).as_str(),
+			(&guest_dir_path).as_str()
+		),
+		format!(
+			"{}/testdir2:{}testdir2",
+			(&host_dir_path).as_str(),
+			(&guest_dir_path).as_str()
+		),
+		format!(
+			"{}/testdir3:{}testdir3/subdir1/subdir2/subdir3",
+			(&host_dir_path).as_str(),
+			(&guest_dir_path).as_str()
+		),
+		format!(
+			"{}/testdir2:{}testdir4",
+			(&host_dir_path).as_str(),
+			(&guest_dir_path).as_str()
+		),
+		format!(
+			"{}/testdir1/testfile_a.txt:/anothermountpoint/test_a.txt",
+			(&host_dir_path).as_str(),
+		),
+	];
+	let guest_file_path = get_testname_derived_guest_path(test_name);
+	let params = generate_params(uhyvefilemap_params.into(), test_name, &guest_file_path);
+
+	let bin_path: PathBuf = build_hermit_bin("fs_tests");
+	let res = run_vm_in_thread(bin_path, params);
+	check_result(&res);
+}
+
 #[test]
 fn lseek_test() {
 	env_logger::try_init().ok();
 
 	let test_name: &'static str = "lseek_file";
-	let guest_file_path = get_testname_derived_guest_path(test_name);
-	let params = generate_params(None, test_name, &guest_file_path);
+	let (filemap, guest_file_path, _tmpdir) = create_filemap(test_name);
+	let params = generate_params(Some(filemap), test_name, &guest_file_path);
 
 	let bin_path: PathBuf = build_hermit_bin("fs_tests");
 	let res = run_vm_in_thread(bin_path, params);

tests/test-kernels/Cargo.lock

@@ -9,7 +9,7 @@ edition = "2024"
 publish = false
 
 [target.'cfg(target_os = "hermit")'.dependencies]
-hermit = "0.11"
+hermit = "0.12"
 
 [target.'cfg(target_arch = "x86_64")'.dependencies]
 x86_64 = { version = "0.15", default-features = false, features = [

tests/test-kernels/Cargo.toml

@@ -128,6 +128,34 @@ fn lseek_file(filename: &str) {
 	assert_eq!(buf, [5, 6, 7, 8, 9, 10, 11, 12, 13, 14]);
 }
 
+fn mount_test() {
+	println!("Mounts Test");
+	let mut f = File::open("/testdir1/testfile_a.txt").unwrap();
+	let mut contents = String::new();
+	f.read_to_string(&mut contents).unwrap();
+	assert_eq!(contents, "12345");
+
+	let mut f = File::open("/testdir2/testfile_b.txt").unwrap();
+	let mut contents = String::new();
+	f.read_to_string(&mut contents).unwrap();
+	assert_eq!(contents, "abcde");
+
+	let mut f = File::open("/testdir3/subdir1/subdir2/subdir3/testfile_c.txt").unwrap();
+	let mut contents = String::new();
+	f.read_to_string(&mut contents).unwrap();
+	assert_eq!(contents, "a1b2c3");
+
+	let mut f = File::open("/testdir4/testfile_b.txt").unwrap();
+	let mut contents = String::new();
+	f.read_to_string(&mut contents).unwrap();
+	assert_eq!(contents, "abcde");
+
+	let mut f = File::open("/anothermountpoint/test_a.txt").unwrap();
+	let mut contents = String::new();
+	f.read_to_string(&mut contents).unwrap();
+	assert_eq!(contents, "12345");
+}
+
 fn main() {
 	let args: Vec<String> = env::args().collect();
 	let testname = &args[1].split('=').collect::<Vec<_>>()[1];
@@ -147,6 +175,7 @@ fn main() {
 		"fd_remove_twice_before_closing" => remove_twice_before_closing(filename),
 		"open_read_only_write" => open_read_only_write(filename),
 		"lseek_file" => lseek_file(filename),
+		"mounts_test" => mount_test(),
 		_ => panic!("test not found"),
 	}
 }