refactor: move HermitImageThinFile into hermit-image-reader

Author: fogti

hermit-image-reader/src/lib.rs

@@ -21,3 +21,5 @@ mod tar_parser;
 pub use tar_parser::{ImageFile, ImageParser, ImageParserError};
 
 pub mod config;
+
+pub mod thin_tree;

hermit-image-reader/src/tar_parser.rs

@@ -1,7 +1,7 @@
 // Copyright (c) 2025 Hermit contributors
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
-use alloc::borrow::Cow;
+use alloc::{borrow::Cow, string::String, vec::Vec};
 use core::ops::Range;
 
 // taken from `tar-rs`
@@ -39,6 +39,8 @@ pub enum ImageParserError {
 	ParseInt(core::num::ParseIntError),
 	FromInt(core::num::TryFromIntError),
 	Utf8(core::str::Utf8Error),
+
+	FileOverridenWithDirectory(Vec<String>),
 }
 
 impl From<core::num::ParseIntError> for ImageParserError {

hermit-image-reader/src/thin_tree.rs

@@ -0,0 +1,90 @@
+// Copyright (c) 2025 Hermit contributors
+// SPDX-License-Identifier: MIT OR Apache-2.0
+
+use alloc::{
+	collections::btree_map::BTreeMap,
+	string::{String, ToString},
+	vec::Vec,
+};
+use core::ops::Range;
+
+use crate::{ImageParser, ImageParserError};
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum ThinTree {
+	File(Range<usize>),
+	Directory(BTreeMap<String, ThinTree>),
+}
+
+impl ThinTree {
+	/// Populate a thin directory tree, with `entry` pointing to `r`
+	pub fn update(&mut self, entry: &[&str], r: Range<usize>) -> Result<(), ImageParserError> {
+		let mut this = self;
+		for (n, i) in entry.iter().copied().enumerate() {
+			let dir = match this {
+				Self::File(r) if r.start == r.end => {
+					*this = Self::Directory(BTreeMap::new());
+					if let Self::Directory(dir) = this {
+						dir
+					} else {
+						unreachable!()
+					}
+				}
+				Self::File(_) => {
+					return Err(ImageParserError::FileOverridenWithDirectory(
+						entry[..=n].iter().map(|i| i.to_string()).collect(),
+					));
+				}
+				Self::Directory(dir) => dir,
+			};
+			this = dir.entry(i.to_string()).or_insert(ThinTree::File(0..0));
+		}
+		*this = Self::File(r);
+		Ok(())
+	}
+
+	pub fn try_from_image(image: &[u8]) -> Result<Self, ImageParserError> {
+		let mut content = Self::File(0..0);
+		for i in ImageParser::new(image) {
+			let i = i?;
+			let name = str::from_utf8(&i.name)?;
+			// multiple entries with the same name might exist,
+			// latest entry wins / overwrites existing ones
+			content.update(&name.split('/').collect::<Vec<_>>(), i.value_range)?;
+		}
+		Ok(content)
+	}
+
+	/// Remove an entry from a thin directory tree
+	pub fn unlink(&mut self, entry: &[&str]) {
+		if entry.is_empty() {
+			// we can't remove ourselves.
+			return;
+		}
+		let (lead, to_remove) = entry.split_at(entry.len() - 1);
+		let this = self.resolve_mut(lead);
+		if let Some(Self::Directory(this)) = this {
+			this.remove(to_remove[0]);
+		}
+	}
+
+	pub fn resolve(&self, entry: &[&str]) -> Option<&ThinTree> {
+		entry.iter().try_fold(self, |this, &i| {
+			if let Self::Directory(dir) = this {
+				dir.get(i)
+			} else {
+				None
+			}
+		})
+	}
+
+	pub fn resolve_mut(&mut self, entry: &[&str]) -> Option<&mut ThinTree> {
+		entry.iter().try_fold(self, |this, &i| {
+			if let Self::Directory(dir) = this {
+				dir.get_mut(i)
+			} else {
+				None
+			}
+		})
+	}
+}

src/hypercall.rs

@@ -13,7 +13,7 @@ use clean_path::clean;
 use uhyve_interface::{GuestPhysAddr, Hypercall, HypercallAddress, MAX_ARGC_ENVC, parameters::*};
 
 use crate::{
-	isolation::filemap::{HermitImageThinFile, MappedFileMutRef, UhyveFileMap},
+	isolation::filemap::{HermitImageThinTree, MappedFileMutRef, UhyveFileMap},
 	mem::{MemoryError, MmapMemory},
 	params::EnvVars,
 	virt_to_phys,
@@ -167,7 +167,7 @@ pub fn open(mem: &MmapMemory, sysopen: &mut OpenParams, file_map: &mut UhyveFile
 			}
 			MappedFileMutRef::InImage {
 				image,
-				thin: HermitImageThinFile::File(r),
+				thin: HermitImageThinTree::File(r),
 			} => {
 				// For simplicity, create a temporary files with these contents.
 				debug!("Attempting to open a temp file for unpacked {guest_path:#?}...");

src/isolation/filemap.rs

@@ -10,6 +10,7 @@ use std::{
 };
 
 use clean_path::clean;
+pub use hermit_image_reader::thin_tree::ThinTree as HermitImageThinTree;
 use tempfile::TempDir;
 use uuid::Uuid;
 
@@ -39,76 +40,12 @@ impl core::ops::Index<Range<usize>> for HermitImage {
 	}
 }
 
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub enum HermitImageThinFile {
-	File(Range<usize>),
-	Directory(HashMap<String, HermitImageThinFile>),
-}
-
-impl HermitImageThinFile {
-	/// Populate a thin directory tree, with `entry` pointing to `r`
-	pub fn update(&mut self, entry: &[&str], r: Range<usize>) {
-		let mut this = self;
-		for i in entry {
-			let dir = match this {
-				Self::File(r) if r.start == r.end => {
-					*this = Self::Directory(HashMap::new());
-					if let Self::Directory(dir) = this {
-						dir
-					} else {
-						unreachable!()
-					}
-				}
-				Self::File(_) => panic!("file in hermit image got overridden"),
-				Self::Directory(dir) => dir,
-			};
-			this = dir
-				.entry(i.to_string())
-				.or_insert(HermitImageThinFile::File(0..0));
-		}
-		*this = Self::File(r);
-	}
-
-	/// Remove an entry from a thin directory tree
-	pub fn unlink(&mut self, entry: &[&str]) {
-		if entry.is_empty() {
-			// we can't remove ourselves.
-			return;
-		}
-		let (lead, to_remove) = entry.split_at(entry.len() - 1);
-		let this = self.resolve_mut(lead);
-		if let Some(Self::Directory(this)) = this {
-			this.remove(to_remove[0]);
-		}
-	}
-
-	pub fn resolve(&self, entry: &[&str]) -> Option<&HermitImageThinFile> {
-		entry.iter().try_fold(self, |this, &i| {
-			if let Self::Directory(dir) = this {
-				dir.get(i)
-			} else {
-				None
-			}
-		})
-	}
-
-	pub fn resolve_mut(&mut self, entry: &[&str]) -> Option<&mut HermitImageThinFile> {
-		entry.iter().try_fold(self, |this, &i| {
-			if let Self::Directory(dir) = this {
-				dir.get_mut(i)
-			} else {
-				None
-			}
-		})
-	}
-}
-
 #[derive(Clone, Debug)]
 pub enum MappedFile {
 	OnHost(PathBuf),
 	InImage {
 		image: Arc<HermitImage>,
-		thin: HermitImageThinFile,
+		thin: HermitImageThinTree,
 	},
 }
 
@@ -117,7 +54,7 @@ pub enum MappedFileMutRef<'a> {
 	OnHost(PathBuf),
 	InImage {
 		image: &'a Arc<HermitImage>,
-		thin: &'a mut HermitImageThinFile,
+		thin: &'a mut HermitImageThinTree,
 	},
 }
 
@@ -203,15 +140,8 @@ impl UhyveFileMap {
 					let mmap = unsafe { MmapOptions::new().map(tmpf.as_file()) }
 						.expect("unable to mmap decompressed hermit image file");
 
-					let mut content = HermitImageThinFile::File(0..0);
-					for i in hermit_image_reader::ImageParser::new(&mmap[..]) {
-						let i = i.expect("unable to read hermit image entry");
-						if let Ok(name) = str::from_utf8(&i.name) {
-							// multiple entries with the same name might exist,
-							// latest entry wins / overwrites existing ones
-							content.update(&name.split('/').collect::<Vec<_>>(), i.value_range);
-						}
-					}
+					let content = HermitImageThinTree::try_from_image(&mmap[..])
+						.expect("unable to parse hermit image file entry");
 
 					(
 						Arc::new(HermitImage {